From 188cf5885dcd1e7c1445511abd730902e255adbd Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Wed, 11 Dec 2013 18:19:18 +0400
Subject: [PATCH 01/22] rx.js: started to make consistent with official
 documentation

---
 rx.js/rx.js.binding.d.ts     |   2 +-
 rx.js/rx.js.d.ts             | 187 ++++++++++++++++++-----------------
 rx.js/rx.js.time.d.ts        |   2 +-
 rx.js/rx.js.virtualtime.d.ts |   8 +-
 4 files changed, 104 insertions(+), 95 deletions(-)

diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.js.binding.d.ts
index b1f7c687a..97a62d0f8 100644
--- a/rx.js/rx.js.binding.d.ts
+++ b/rx.js/rx.js.binding.d.ts
@@ -28,7 +28,7 @@ declare module Rx {
     }
 
 	interface ConnectableObservable<T> extends IObservable<T>{
-		connect(): _IDisposable;
+		connect(): IDisposable;
 		refCount(): IObservable<T>;
     }
 
diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts
index aeefce98f..0b9c03de7 100644
--- a/rx.js/rx.js.d.ts
+++ b/rx.js/rx.js.d.ts
@@ -8,7 +8,7 @@ declare module Rx {
 	export module Internals {
 		function inherits(child: Function, parent: Function): Function;
 		function addProperties(obj: Object, ...sourcces: Object[]): void;
-		function addRef<T>(xs: IObservable<T>, r: { getDisposable(): _IDisposable; }): IObservable<T>;
+		function addRef<T>(xs: IObservable<T>, r: { getDisposable(): IDisposable; }): IObservable<T>;
 	}
 
 	//Collections
@@ -34,142 +34,147 @@ declare module Rx {
 		remove(item: IIndexedItem): boolean;
 	}
 
-	interface _IDisposable {
+	interface IDisposable {
 		dispose(): void;
 	}
 
-	export class CompositeDisposable {
-		constructor (...disposables: _IDisposable[]);
+	export class CompositeDisposable implements IDisposable {
+		constructor (...disposables: IDisposable[]);
+		constructor (disposables: IDisposable[]);
 
-		disposables: _IDisposable[];
 		isDisposed: boolean;
 		length: number;
 
 		dispose(): void;
-		add(item: _IDisposable): void;
-		remove(item: _IDisposable): boolean;
+		add(item: IDisposable): void;
+		remove(item: IDisposable): boolean;
 		clear(): void;
-		contains(item: _IDisposable): boolean;
-		toArray(): _IDisposable[];
+		contains(item: IDisposable): boolean;
+		toArray(): IDisposable[];
 	}
 
-	// Main disposable class
-	interface IDisposable {
+	export class Disposable implements IDisposable {
+		constructor(action: () => void);
+
+		static create(action: () => void): IDisposable;
+		static empty: IDisposable;
+
 		isDisposed: boolean;
-		action: () =>void;
+		action: () => void;
 
 		dispose(): void;
 	}
 
-	export interface Disposable {
-		new (action: () =>void ): IDisposable;
-	}
-
-	var Disposable: {
-		create(action: () => void): _IDisposable;
-		empty: _IDisposable;
-	}
-
 	// Single assignment
-	interface ISingleAssignmentDisposable {
-		isDisposed: boolean;
-		current: _IDisposable;
+	export class SingleAssignmentDisposable implements IDisposable {
+		constructor();
 
-		dispose(): void;
-		disposable(value?: _IDisposable): _IDisposable;
-		getDisposable(): _IDisposable;
-		setDisposable(value: _IDisposable): void;
-	}
-	export interface SingleAssignmentDisposable {
-		(): ISingleAssignmentDisposable;
+		isDisposed: boolean;
+		current: IDisposable;
+
+		dispose(): void ;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void ;
 	}
 
 	// Multiple assignment disposable
-	export class SerialDisposable {
+	export class SerialDisposable implements IDisposable {
+		constructor();
+
 		isDisposed: boolean;
-		current: _IDisposable;
 
 		dispose(): void;
-		getDisposable(): _IDisposable;
-		setDisposable(value: _IDisposable): void;
-		disposable(value?: _IDisposable): _IDisposable;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void;
 	}
 
-	export class RefCountDisposable {
-		constructor(disposable: _IDisposable);
-
-		underlyingDisposable: _IDisposable;
-		isDisposed: boolean;
-		isPrimaryDisposed: boolean;
-		count: number;
+	export class RefCountDisposable implements IDisposable {
+		constructor(disposable: IDisposable);
 
 		dispose(): void;
-		getDisposable(): _IDisposable;
+
+		isDisposed: boolean;
+		getDisposable(): IDisposable;
 	}
 
 	interface IScheduledItem {
 		scheduler: IScheduler;
 		state: any;
-		action: (scheduler: IScheduler, state) => _IDisposable;
+		action: (scheduler: IScheduler, state) => IDisposable;
 		dueTime: number;
 		comparer: (x: number, y: number) =>number;
-		disposable: ISingleAssignmentDisposable;
+		disposable: SingleAssignmentDisposable;
 
 		invoke(): void;
 		compareTo(other: IScheduledItem): number;
 		isCancelled(): boolean;
-		invokeCore(): _IDisposable;
+		invokeCore(): IDisposable;
 	}
 
 	interface IScheduler {
-		_schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable;
-		_scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
-		_scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable;
-
 		now(): number;
-		scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
-		scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
-		scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
+		catch(handler: (exception: any) => boolean): IScheduler;
+		catchException(handler: (exception: any) => boolean): IScheduler;
 
-		catchException(handler: (exception: any) =>boolean): ICatchScheduler;
-		schedulePeriodic(period: number, action: () =>void ): _IDisposable;
-		schedulePeriodicWithState(state: any, period: number, action: (state: any) =>any): _IDisposable;//returns {Disposable|SingleAssignmentDisposable}
-		schedule(action: () =>void ): _IDisposable;
-		scheduleWithRelative(dueTime: number, action: () =>void ): _IDisposable;
-		scheduleWithAbsolute(dueTime: number, action: () =>void ): _IDisposable;
-		scheduleRecursive(action: (action: () =>void ) =>void ): _IDisposable;
-		scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): _IDisposable;
-		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
-		scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
-		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): _IDisposable;
-		scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): _IDisposable;
+		schedule(action: () => void): IDisposable;
+		scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
 	}
 
-	var Scheduler: {
-		//(now: () =>number,
-		//	schedule: (state: any, action: (scheduler: IScheduler, state: any) =>_IDisposable) => _IDisposable,
-		//	scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable,
-		//	scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable) =>_IDisposable
-		//	): IScheduler;
+	export class Scheduler implements IScheduler {
+		constructor(
+			now: () => number,
+			schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable);
+
+		static normalize(timeSpan: number): number;
+
+		static immediate: IScheduler;
+		static currentThread: ICurrentThreadScheduler;
+		static timeout: IScheduler;
 
 		now(): number;
-		normalize(timeSpan: number): number;
+		catch(handler: (exception: any) => boolean): IScheduler;
+		catchException(handler: (exception: any) => boolean): IScheduler;
 
-		immediate: IScheduler;
-		currentThread: ICurrentScheduler;//IScheduler;
-		timeout: IScheduler;
+		schedule(action: () => void): IDisposable;
+		scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () => void) => void): IDisposable;
+		scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
 	}
 
 	// Current Thread IScheduler
-	interface ICurrentScheduler extends IScheduler {
+	interface ICurrentThreadScheduler extends IScheduler {
 		scheduleRequired(): boolean;
-		ensureTrampoline(action: () =>_IDisposable): _IDisposable;
+		ensureTrampoline(action: () =>IDisposable): IDisposable;
 	}
 
-
-	// CatchScheduler
-	interface ICatchScheduler extends IScheduler { }
-
 	// Notifications
 	interface INotification<T> {
 		accept(observer: IObserver<T>): void;
@@ -283,12 +288,12 @@ declare module Rx {
 	}
 
 	interface IObservable<T> {
-		_subscribe: (observer: IObserver<T>) =>_IDisposable;
+		_subscribe: (observer: IObserver<T>) =>IDisposable;
 
-		subscribe(observer: IObserver<T>): _IDisposable;
+		subscribe(observer: IObserver<T>): IDisposable;
 
 		finalValue(): IObservable<T>;
-		subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): _IDisposable;
+		subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IDisposable;
 		toArray(): IObservable<T>;
 
 		observeOn(scheduler: IScheduler): IObservable<T>;
@@ -352,11 +357,11 @@ declare module Rx {
 	}
 
 	interface Observable {
-		(subscribe: (observer: IObserver<any>) =>_IDisposable): IObservable<any>;
+		(subscribe: (observer: IObserver<any>) =>IDisposable): IObservable<any>;
 
 		create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
-		//create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
-		createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>_IDisposable): IObservable<T>;
+		create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
+		createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>IDisposable): IObservable<T>;
 		defer<T>(observableFactory: () => IObservable<T>): IObservable<T>;
 		empty<T>(scheduler?: IScheduler): IObservable<T>;
 		fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
@@ -365,7 +370,11 @@ declare module Rx {
 		never<T>(): IObservable<T>;
 		range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
 		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
+		return<T>(value: T, scheduler?: IScheduler): IObservable<T>;
 		returnValue<T>(value: T, scheduler?: IScheduler): IObservable<T>;
+		throw<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
+		throw<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
+		throwException<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
 		throwException<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
 		using<TSource, TResource>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable<TSource>): IObservable<TSource>;
 		amb<T>(...sources: IObservable<T>[]): IObservable<T>;
@@ -387,7 +396,7 @@ declare module Rx {
 	export module Internals {
 		interface IAnonymousObservable<T> extends IObservable<T> { }
 		export interface AnonymousObservable<T> {
-			(subscribe: (observer: IObserver<T>) =>_IDisposable): IAnonymousObservable<T>;
+			(subscribe: (observer: IObserver<T>) =>IDisposable): IAnonymousObservable<T>;
 		}
 	}
 
diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts
index f458dadc3..6e9a6e9f2 100644
--- a/rx.js/rx.js.time.d.ts
+++ b/rx.js/rx.js.time.d.ts
@@ -51,7 +51,7 @@ declare module Rx {
 		skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
 		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
 
-		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<Array>;
+		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<T[]>;
 		takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
 		skipWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
 
diff --git a/rx.js/rx.js.virtualtime.d.ts b/rx.js/rx.js.virtualtime.d.ts
index 24d40e601..04b39acec 100644
--- a/rx.js/rx.js.virtualtime.d.ts
+++ b/rx.js/rx.js.virtualtime.d.ts
@@ -19,16 +19,16 @@ declare module Rx {
         comparer: (x: number, y: number) =>number;
         isEnabled: boolean;
         queue: IPriorityQueue;
-        scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
-        scheduleRelative(dueTime: number, action: () =>void ): _IDisposable;
-        start(): _IDisposable;
+        scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
+        scheduleRelative(dueTime: number, action: () =>void ): IDisposable;
+        start(): IDisposable;
         stop(): void;
         advanceTo(time: number);
         advanceBy(time: number);
         sleep(time: number);
         getNext(): IScheduledItem;
         scheduleAbsolute(dueTime: number, action: () =>void );
-        scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>_IDisposable): _IDisposable;
+        scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
     }
     //export module VirtualTimeScheduler {
     //    //absract

From 64b0b3c08871338358fdaf8af5af6ae0b17c8a8e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Fri, 6 Dec 2013 15:05:59 +0400
Subject: [PATCH 02/22] rx.js: fixed rx.js.time.d.ts errors related to switch
 on TS 0.9.5; some over minor fixes

---
 rx.js/rx.js.time.d.ts | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts
index 6e9a6e9f2..e329a823c 100644
--- a/rx.js/rx.js.time.d.ts
+++ b/rx.js/rx.js.time.d.ts
@@ -42,11 +42,11 @@ declare module Rx {
 		timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
 
 		delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		delayWithSelector(delayDurationSelector: (T) => number): IObservable<T>;
-		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (T) => number): IObservable<T>;
+		delayWithSelector(delayDurationSelector: (item: T) => number): IObservable<T>;
+		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): IObservable<T>;
 
-		timeoutWithSelector<TTimeout>(firstTimeout: IObservable<TTimeout>, timeoutdurationSelector?: (T) => IObservable<TTimeout>, other?: IObservable<T>): IObservable<T>;
-		throttleWithSelector<TTimeout>(throttleDurationSelector: (T) => IObservable<TTimeout>): IObservable<T>;
+		timeoutWithSelector<TTimeout>(firstTimeout: IObservable<TTimeout>, timeoutdurationSelector?: (item: T) => IObservable<TTimeout>, other?: IObservable<T>): IObservable<T>;
+		throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => IObservable<TTimeout>): IObservable<T>;
 
 		skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
 		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
@@ -69,18 +69,18 @@ declare module Rx {
 
 		generateWithAbsoluteTime<TState, TResult>(
 			initialState: TState,
-			condition: (TState) => boolean,
-			iterate: (TState) => TState,
-			resultSelector: (TState) => TResult,
-			timeSelector: (TState) => Date,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => Date,
 			scheduler?: IScheduler): IObservable<TResult>;
 
 		generateWithRelativeTime<TState, TResult>(
 			initialState: TState,
-			condition: (TState) => boolean,
-			iterate: (TState) => TState,
-			resultSelector: (TState) => TResult,
-			timeSelector: (TState) => number,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => number,
 			scheduler?: IScheduler): IObservable<TResult>;
 	}
 }
\ No newline at end of file

From 09a654307a0621bc9ea7b936334c0141e19dec0f Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 14 Dec 2013 00:36:32 +0400
Subject: [PATCH 03/22] rx.js: renamed some interfaces to documentation
 consistent names (IObservable->Observable) added test for rx.js.d.ts

---
 rx.js/rx-tests.ts             | 135 +++++++++++
 rx.js/rx.js.aggregates.d.ts   |  66 +++---
 rx.js/rx.js.async.d.ts        |  14 +-
 rx.js/rx.js.binding.d.ts      |  12 +-
 rx.js/rx.js.coincidence.d.ts  |  26 +--
 rx.js/rx.js.d.ts              | 427 ++++++++++++++--------------------
 rx.js/rx.js.experimental.d.ts |  50 ++--
 rx.js/rx.js.joinpatterns.d.ts |   2 +-
 rx.js/rx.js.jquery.d.ts       |  76 +++---
 rx.js/rx.js.time.d.ts         |  88 +++----
 10 files changed, 477 insertions(+), 419 deletions(-)
 create mode 100644 rx.js/rx-tests.ts

diff --git a/rx.js/rx-tests.ts b/rx.js/rx-tests.ts
new file mode 100644
index 000000000..14388c49f
--- /dev/null
+++ b/rx.js/rx-tests.ts
@@ -0,0 +1,135 @@
+///<reference path="rx.js.d.ts"/>
+
+// Disposable
+var d: Rx.IDisposable = new Rx.Disposable(() => { });
+d = Rx.Disposable.create(() => { });
+d = Rx.Disposable.empty;
+d.dispose();
+
+// CompositeDisposable
+var cd = new Rx.CompositeDisposable(d, d, d);
+d = cd;
+cd = new Rx.CompositeDisposable([d, d]);
+cd.add(d);
+cd.clear();
+var b: boolean = cd.contains(d);
+var da: Rx.IDisposable[] = cd.toArray();
+cd.remove(d);
+
+// SingleAssignmentDisposable
+var sad = new Rx.SingleAssignmentDisposable();
+d = sad;
+sad.setDisposable(d);
+d = sad.getDisposable();
+b = sad.isDisposed;
+
+// SerialDisposable
+var sd = new Rx.SerialDisposable();
+d = sd;
+sd.setDisposable(d);
+d = sd.getDisposable();
+b = sd.isDisposed;
+
+// RefCountDisposable
+var rcd = new Rx.RefCountDisposable(d);
+d = rcd;
+d = rcd.getDisposable();
+b = rcd.isDisposed;
+
+// IScheduler
+var s: Rx.IScheduler;
+var n: number = s.now();
+s = s.catch(ex => true);
+s = s.catchException(ex => true);
+d = s.schedule(() => { });
+d = s.scheduleWithState(1,
+	(sh, s) => sh.scheduleWithAbsoluteAndState(s + 1, 100,
+		(sh, s) => sh.scheduleWithRelativeAndState(s + 1, 200,
+			(sh, s) => sh.scheduleRecursiveWithState(s + 1,
+				(s, self) => self(s + 1)))));
+d = s.scheduleWithAbsolute(100, () => { });
+d = s.scheduleWithRelative(100, () => { });
+d = s.scheduleRecursive(self => self());
+d = s.scheduleRecursiveWithAbsolute(100, self => self(200));
+d = s.scheduleRecursiveWithRelative(100, self => self(200));
+d = s.schedulePeriodic(100, () => { });
+d = s.schedulePeriodicWithState('a', 100, s => s + 'b');
+
+// ICurrentThreadScheduler
+Rx.Scheduler.currentThread.scheduleRequired();
+Rx.Scheduler.currentThread.ensureTrampoline(() => Rx.Disposable.empty);
+
+// Observer
+var o: Rx.Observer<number> = Rx.Observer.create<number>();
+o = Rx.Observer.create<number>(i => { });
+o = Rx.Observer.create<number>(i => { }, err => { });
+o = Rx.Observer.create<number>(i => { }, err => { }, () => { });
+o = Rx.Observer.fromNotifier<number>(n => { });
+
+o.onNext(10);
+o.onError(new Error());
+o.onCompleted();
+
+// Observable static methods tests
+
+var ns: Rx.Observable<number> = Rx.Observable.create<number>(observer => { });
+var ss: Rx.Observable<string> = Rx.Observable.create<string>(observer => (() => { }));
+var bs: Rx.Observable<boolean> = Rx.Observable.createWithDisposable<boolean>(observer => Rx.Disposable.empty);
+
+ns = Rx.Observable.defer(() => ns);
+
+ss = Rx.Observable.empty<string>();
+bs = Rx.Observable.empty<boolean>(Rx.Scheduler.currentThread);
+
+ns = Rx.Observable.fromArray([0, 3, -7, 18]);
+ss = Rx.Observable.fromArray(['a', 'ab', 'abc'], Rx.Scheduler.timeout);
+
+ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i);
+ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i, Rx.Scheduler.timeout);
+
+bs = Rx.Observable.never<boolean>();
+
+ns = Rx.Observable.range(0, 100);
+ns = Rx.Observable.range(0, 100, Rx.Scheduler.timeout);
+
+ns = Rx.Observable.repeat(0, 100);
+ns = Rx.Observable.repeat(0, 100, Rx.Scheduler.timeout);
+
+ss = Rx.Observable.return('a');
+ss = Rx.Observable.return('a', Rx.Scheduler.timeout);
+ss = Rx.Observable.returnValue('a');
+ss = Rx.Observable.returnValue('a', Rx.Scheduler.timeout);
+
+bs = Rx.Observable.throw<boolean>(new Error("error"));
+bs = Rx.Observable.throw<boolean>(new Error("error"), Rx.Scheduler.timeout);
+bs = Rx.Observable.throwException<boolean>(new Error("error"));
+bs = Rx.Observable.throwException<boolean>(new Error("error"), Rx.Scheduler.timeout);
+
+bs = Rx.Observable.using(() => d, d => Rx.Observable.return(true));
+
+ss = Rx.Observable.amb(ss, ss);
+//ss = Rx.Observable.amb([ss, ss]);
+
+ss = Rx.Observable.catch(ss, ss, ss);
+ss = Rx.Observable.catchException(ss, ss, ss);
+//ss = Rx.Observable.catch([ss, ss, ss]);
+//ss = Rx.Observable.catchException([ss, ss, ss]);
+
+ss = Rx.Observable.concat(ss, ss, ss);
+//ss = Rx.Observable.concat([ss, ss, ss]);
+
+ss = Rx.Observable.merge(ss, ss, ss);
+//ss = Rx.Observable.merge([ss, ss, ss]);
+ss = Rx.Observable.merge(s, ss, ss, ss);
+//ss = Rx.Observable.merge(s, [ss, ss, ss]);
+
+ss = Rx.Observable.onErrorResumeNext(ss, ss, ss);
+//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);
+
+ns = Rx.Observable.zip(ss, bs, ns, (s, b, n) => s.length + (b ? 1 : 0) + n);
+
+
+// Observable instance methods
+
+var sss: Rx.Observable<Rx.Observable<string>>;
+ss = sss.concatAll();
\ No newline at end of file
diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts
index 93a304db4..1955bfe7f 100644
--- a/rx.js/rx.js.aggregates.d.ts
+++ b/rx.js/rx.js.aggregates.d.ts
@@ -10,44 +10,44 @@
 // -> rx.aggregates.js
 
 declare module Rx {
-	interface IObservable<T> {
-		aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
-		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
+	export interface Observable<T> {
+		aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
 
-		any(): IObservable<boolean>;
-		any(selector: (item: T) => boolean): IObservable<boolean>;
+		any(): Observable<boolean>;
+		any(selector: (item: T) => boolean): Observable<boolean>;
 
-		isEmpty(predicate?: (value: T) => boolean): IObservable<boolean>;
-		all(predicate?: (value: T) => boolean): IObservable<boolean>;
-		contains(value: T, comparer?: (value1: T, value2: T) => boolean): IObservable<boolean>;
-		count(predicate?: (item: T) => boolean): IObservable<number>;
-		sum(keySelector?: (item: T) => number): IObservable<number>;
-		minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
-		min(comparer?: (value1: T, value2: T) => number): IObservable<T>;
-		maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): IObservable<T>;
-		max(comparer?: (value1: T, value2: T) => number): IObservable<number>;
-		average(keySelector?: (item: T) => number): IObservable<number>;
+		isEmpty(predicate?: (value: T) => boolean): Observable<boolean>;
+		all(predicate?: (value: T) => boolean): Observable<boolean>;
+		contains(value: T, comparer?: (value1: T, value2: T) => boolean): Observable<boolean>;
+		count(predicate?: (item: T) => boolean): Observable<number>;
+		sum(keySelector?: (item: T) => number): Observable<number>;
+		minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		min(comparer?: (value1: T, value2: T) => number): Observable<T>;
+		maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		max(comparer?: (value1: T, value2: T) => number): Observable<number>;
+		average(keySelector?: (item: T) => number): Observable<number>;
 
-		sequenceEqual(second: IObservable<T>, comparer?: (value1: T, value2: T) => number): IObservable<T>;
-		elementAt(index: number): IObservable<T>;
-		elementAtOrDefault(index: number, defaultValue: T): IObservable<T>;
+		sequenceEqual(second: Observable<T>, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		elementAt(index: number): Observable<T>;
+		elementAtOrDefault(index: number, defaultValue: T): Observable<T>;
 
-		single(): IObservable<T>;
-		single(predicate: (T) => boolean): IObservable<T>;
-		singleOrDefault(): IObservable<T>;
-		singleOrDefault(predicate: (T) => boolean): IObservable<T>;
-		singleOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
+		single(): Observable<T>;
+		single(predicate: (item: T) => boolean): Observable<T>;
+		singleOrDefault(): Observable<T>;
+		singleOrDefault(predicate: (item: T) => boolean): Observable<T>;
+		singleOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
 
-		first(): IObservable<T>;
-		first(predicate: (T) => boolean): IObservable<T>;
-		firstOrDefault(): IObservable<T>;
-		firstOrDefault(predicate: (T) => boolean): IObservable<T>;
-		firstOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
+		first(): Observable<T>;
+		first(predicate: (item: T) => boolean): Observable<T>;
+		firstOrDefault(): Observable<T>;
+		firstOrDefault(predicate: (item: T) => boolean): Observable<T>;
+		firstOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
 
-		last(): IObservable<T>;
-		last(predicate: (T) => boolean): IObservable<T>;
-		lastOrDefault(): IObservable<T>;
-		lastOrDefault(predicate: (T) => boolean): IObservable<T>;
-		lastOrDefault(predicate: (T) => boolean, defaultValue: T): IObservable<T>;
+		last(): Observable<T>;
+		last(predicate: (item: T) => boolean): Observable<T>;
+		lastOrDefault(): Observable<T>;
+		lastOrDefault(predicate: (item: T) => boolean): Observable<T>;
+		lastOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
 	}
 }
\ No newline at end of file
diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts
index 98fb930f7..fa336ac7e 100644
--- a/rx.js/rx.js.async.d.ts
+++ b/rx.js/rx.js.async.d.ts
@@ -11,12 +11,12 @@
 
 declare module Rx {
     interface Observable {
-        start<T>(func: () => T, scheduler?: IScheduler, context?: any): IObservable<T>;
-        toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => IObservable<T>;
-        fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => IObservable<T>;
-        fromNodeCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => IObservable<T>;
-        fromEvent<T>(element: any, eventName: string, selector?: (...arguments: any[])=>T): IObservable<T>;
-        fromEventPattern<T>(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): IObservable<T>;
-        fromPromise<T>(promise: any): IObservable<T>;
+        start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
+        toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => Observable<T>;
+        fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => Observable<T>;
+        fromNodeCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => Observable<T>;
+        fromEvent<T>(element: any, eventName: string, selector?: (...arguments: any[])=>T): Observable<T>;
+        fromEventPattern<T>(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): Observable<T>;
+        fromPromise<T>(promise: any): Observable<T>;
     }
 }
\ No newline at end of file
diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.js.binding.d.ts
index 97a62d0f8..0921f30c5 100644
--- a/rx.js/rx.js.binding.d.ts
+++ b/rx.js/rx.js.binding.d.ts
@@ -27,25 +27,25 @@ declare module Rx {
         new <T>(initialValue: T): BehaviorSubject<T>;
     }
 
-	interface ConnectableObservable<T> extends IObservable<T>{
+	interface ConnectableObservable<T> extends Observable<T>{
 		connect(): IDisposable;
-		refCount(): IObservable<T>;
+		refCount(): Observable<T>;
     }
 
     var ConnectableObservable: {
         new <T>(): ConnectableObservable<T>;
     }
 
-	interface IObservable<T> {
+	interface Observable<T> {
 
 		publish(): ConnectableObservable<T>;
-		publish<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
+		publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
 		publishLast(): ConnectableObservable<T>;
-		publishLast<TResult>(selector: (item: T) => IObservable<TResult>): ConnectableObservable<TResult>;
+		publishLast<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
 		publishValue(initialValue: T): ConnectableObservable<T>;
 		publishValue<TResult>(selector: (item: T) => TResult, initialValue: TResult): ConnectableObservable<TResult>;
 
-		replay(selector?: (source: IObservable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+		replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
 	}
 
 
diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts
index 138e99236..7aa0ae65a 100644
--- a/rx.js/rx.js.coincidence.d.ts
+++ b/rx.js/rx.js.coincidence.d.ts
@@ -11,27 +11,27 @@
 
 declare module Rx {
 
-	interface IObservable<T> {
+	interface Observable<T> {
 		join<T2, TDuration, T2Duration, TResult>(
-			right: IObservable<T2>,
-			leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
-			rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
-			resultSelector: (leftItem: T, rightItem: T2) => TResult): IObservable<TResult>;
+			right: Observable<T2>,
+			leftDurationSelector: (leftItem: T) => Observable<TDuration>,
+			rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
+			resultSelector: (leftItem: T, rightItem: T2) => TResult): Observable<TResult>;
 
 		groupJoin<T2, TDuration, T2Duration, TResult>(
-			right: IObservable<T2>,
-			leftDurationSelector: (leftItem: T) => IObservable<TDuration>,
-			rightDurationSelector: (rightItem: T2) => IObservable<T2Duration>,
-			resultSelector: (leftItem: T, rightItem: IObservable<T2>) => TResult): IObservable<TResult>;
+			right: Observable<T2>,
+			leftDurationSelector: (leftItem: T) => Observable<TDuration>,
+			rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
+			resultSelector: (leftItem: T, rightItem: Observable<T2>) => TResult): Observable<TResult>;
 
 
 		// lack of documentation to complete the followings...
 
-		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
-			bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
+		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
+			bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
 
-		window<TBufferOpening, TBufferClosing>(bufferOpenings: IObservable<TBufferOpening>,
-			bufferClosingSelector: (opening: TBufferOpening) => IObservable<TBufferClosing>): IObservable<T>;
+		window<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
+			bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
 	}
 
 
diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts
index 0b9c03de7..7107afb1e 100644
--- a/rx.js/rx.js.d.ts
+++ b/rx.js/rx.js.d.ts
@@ -8,7 +8,7 @@ declare module Rx {
 	export module Internals {
 		function inherits(child: Function, parent: Function): Function;
 		function addProperties(obj: Object, ...sourcces: Object[]): void;
-		function addRef<T>(xs: IObservable<T>, r: { getDisposable(): IDisposable; }): IObservable<T>;
+		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
 	}
 
 	//Collections
@@ -34,7 +34,7 @@ declare module Rx {
 		remove(item: IIndexedItem): boolean;
 	}
 
-	interface IDisposable {
+	export interface IDisposable {
 		dispose(): void;
 	}
 
@@ -59,9 +59,6 @@ declare module Rx {
 		static create(action: () => void): IDisposable;
 		static empty: IDisposable;
 
-		isDisposed: boolean;
-		action: () => void;
-
 		dispose(): void;
 	}
 
@@ -111,27 +108,27 @@ declare module Rx {
 		invokeCore(): IDisposable;
 	}
 
-	interface IScheduler {
+	export interface IScheduler {
 		now(): number;
 		catch(handler: (exception: any) => boolean): IScheduler;
 		catchException(handler: (exception: any) => boolean): IScheduler;
 
 		schedule(action: () => void): IDisposable;
-		scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
 		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
 		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
 
 		scheduleRecursive(action: (action: () =>void ) =>void ): IDisposable;
-		scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) =>void ) =>void ): IDisposable;
 		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
-		scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
 		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) =>void ) =>void ): IDisposable;
-		scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) =>void ) =>void ): IDisposable;
+		scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
 
 		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
 	}
 
 	export class Scheduler implements IScheduler {
@@ -152,21 +149,21 @@ declare module Rx {
 		catchException(handler: (exception: any) => boolean): IScheduler;
 
 		schedule(action: () => void): IDisposable;
-		scheduleWithState(state: any, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
 		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
 		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
 
 		scheduleRecursive(action: (action: () => void) => void): IDisposable;
-		scheduleRecursiveWithState(state: any, action: (state: any, action: (state: any) => void) => void): IDisposable;
+		scheduleRecursiveWithState<TState>(state: TState, action: (state: TState, action: (state: TState) => void) => void): IDisposable;
 		scheduleRecursiveWithAbsolute(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
-		scheduleRecursiveWithAbsoluteAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
 		scheduleRecursiveWithRelative(dueTime: number, action: (action: (dueTime: number) => void) => void): IDisposable;
-		scheduleRecursiveWithRelativeAndState(state: any, dueTime: number, action: (state: any, action: (state: any, dueTime: number) => void) => void): IDisposable;
+		scheduleRecursiveWithRelativeAndState<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
 
 		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState(state: any, period: number, action: (state: any) => any): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
 	}
 
 	// Current Thread IScheduler
@@ -176,267 +173,193 @@ declare module Rx {
 	}
 
 	// Notifications
-	interface INotification<T> {
-		accept(observer: IObserver<T>): void;
-		accept(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): void;
-		toObservable(scheduler?: IScheduler): IObservable<any>;
+	export class Notification<T> {
+		accept(observer: Observer<T>): void;
+		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
+		toObservable(scheduler?: IScheduler): Observable<T>;
 		hasValue: boolean;
-		equals(other: INotification<T>): boolean;
+		equals(other: Notification<T>): boolean;
 		kind: string;
-		value?: T;
-		exception?: any;
-	}
-	export interface Notification {
-		//abstract
-		//function new (): INotification;
+		value: T;
+		exception: any;
 
-		createOnNext<T>(value: T): INotification<T>;//ON
-		createOnError<T>(exception): INotification<T>;//OE
-		createOnCompleted<T>(): INotification<T>;//OC
-	}
-
-	var Notification: Notification;
-
-	export module Internals {
-		// Enumerator
-		interface IEnumerator<T> {
-			moveNext(): boolean;
-			getCurrent(): T;
-			dispose(): void;
-		}
-		export interface Enumerator<T> {
-			(moveNext: () =>boolean, getCurrent: () => T, dispose: () =>void ): IEnumerator<T>;
-
-			create(moveNext: () =>boolean, getCurrent: () => T, dispose?: () =>void ): IEnumerator<T>;
-		}
-
-		// Enumerable
-		interface IEnumerable<T> {
-			getEnumerator(): IEnumerator<T>;
-
-			concat(): IObservable<T>;
-			catchException(): IObservable<T>;
-		}
-		export interface Enumerable<T> {
-			(getEnumerator: () =>IEnumerator<T>): IEnumerable<T>;
-
-			repeat(value: T, repeatCount?: number): IEnumerable<any>;
-			forEach<T2>(source: T[], selector?: (element: T, index: number) => T2): IEnumerable<T2>;
-			forEach<T2>(source: { length: number; [index: number]: T; }, selector?: (element: T, index: number) => T2): IEnumerable<T2>;
-		}
+		static createOnNext<T>(value: T): Notification<T>;
+		static createOnError<T>(exception): Notification<T>;
+		static createOnCompleted<T>(): Notification<T>;
 	}
 
 	// Observer
-	interface IObserver<T> {
+	export class Observer<T> {
 		onNext(value: T): void;
 		onError(exception: any): void;
 		onCompleted(): void;
 
-		toNotifier(): (notification: INotification<T>) =>void;
-		asObserver(): IObserver<T>;
-		checked(): ICheckedObserver<any>;
-	}
-	export module Observer {
-		//abstract
-		//function new (): IObserver;
+		toNotifier(): (notification: Notification<T>) =>void;
+		asObserver(): Observer<T>;
+		checked(): Observer<any>;
 
-		function create<T>(onNext: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObserver<T>;
-		function fromNotifier<T>(handler: (notification: INotification<T>) =>void ): IObserver<T>;
+		static create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
+		static fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
 	}
 
-	export module Internals {
-		// Abstract Observer
-		interface IAbstractObserver<T> extends IObserver<T> {
-			isStopped: boolean;
+	export interface Observable<T> {
+		_subscribe: (observer: Observer<T>) => IDisposable;
 
-			dispose(): void;
-			next(value: T): void;
-			error(exception: any): void;
-			completed(): void;
-			fail(): boolean;
-		}
-		//export module AbstractObserver {
-		//    //abstract
-		//    function new (): IAbstractObserver;
-		//}
+		subscribe(observer: Observer<T>): IDisposable;
+
+		finalValue(): Observable<T>;
+		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
+		toArray(): Observable<T>;
+
+		observeOn(scheduler: IScheduler): Observable<T>;
+		subscribeOn(scheduler: IScheduler): Observable<T>;
+
+		amb(rightSource: Observable<T>): Observable<T>;
+		catchException(handler: (exception: any) => Observable<T>): Observable<T>;
+		catchException(second: Observable<T>): Observable<T>;
+		combineLatest<T2, TResult>(second: Observable<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, 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, 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<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
+		concat(...sources: Observable<T>[]): Observable<T>;
+		concat(sources: Observable<T>[]): Observable<T>;
+		concatObservable(): T;
+		concatAll(): T;
+		merge(maxConcurrent: number): Observable<T>;
+		merge(other: Observable<T>): Observable<T>;
+		mergeObservable(): T;
+		mergeAll(): T;
+		onErrorResumeNext(second: Observable<T>): Observable<T>;
+		skipUntil<T2>(other: Observable<T2>): Observable<T>;
+		switchLatest(): Observable<T>;
+		takeUntil<T2>(other: Observable<T2>): Observable<T>;
+		zip<T2, TResult>(second: Observable<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, 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, 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<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
+		zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): Observable<TResult>;
+		asIObservable(): Observable<any>;
+		bufferWithCount(count: number, skip?: number): Observable<T>;
+		dematerialize<TOrigin>(): Observable<TOrigin>;
+		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<any>;
+		doAction(observer: Observer<T>): Observable<T>;
+		doAction(onNext: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
+		finallyAction(action: () => void): Observable<T>;
+		ignoreElements(): Observable<T>;
+		materialize(): Observable<Notification<T>>;
+		repeat(repeatCount?: number): Observable<T>;
+		retry(retryCount?: number): Observable<T>;
+		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		skipLast(count: number): Observable<T>;
+		startWith(...values: T[]): Observable<T>;
+		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
+		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
+		takeLastBuffer(count: number): Observable<T>;
+		windowWithCount(count: number, skip?: number): Observable<T>;
+		defaultIfEmpty(defaultValue?: T): Observable<T>;
+		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
+		groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<number>, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
+		select<T2>(selector: (value: T, index: number) => T2): Observable<T2>;
+		selectMany<T2>(selector: (value: T) => Observable<T2>, resultSelector?: (x: any, y: any) => any): Observable<T2>;
+		selectMany<T2>(other: Observable<T2>): Observable<T2>;
+		skip(count: number): Observable<T>;
+		skipWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
+		take(count: number, scheduler?: IScheduler): Observable<T>;
+		takeWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
+		where(predicate: (value: T, index?: number) => boolean): Observable<T>;
 	}
 
-	export class AnonymousObserver<T> {
-		constructor(onNext: (value: T) => void , onError: (exception: any) => void , onCompleted: () => void);
+	interface ObservableStatic {
+		create<T>(subscribe: (observer: Observer<T>) => void): Observable<T>;
+		create<T>(subscribe: (observer: Observer<T>) => () => void): Observable<T>;
+		createWithDisposable<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
+		defer<T>(observableFactory: () => Observable<T>): Observable<T>;
+		empty<T>(scheduler?: IScheduler): Observable<T>;
+		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
+		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
+		generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): Observable<TResult>;
+		never<T>(): Observable<T>;
+		range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
+		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
+		return<T>(value: T, scheduler?: IScheduler): Observable<T>;
+		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;
+		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
+		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
+		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
+		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;
+		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
+		amb<T>(...sources: Observable<T>[]): Observable<T>;
+		amb<T>(sources: Observable<T>[]): Observable<T>;
+		catch<T>(sources: Observable<T>[]): Observable<T>;
+		catchException<T>(sources: Observable<T>[]): Observable<T>;
+		catch<T>(...sources: Observable<T>[]): Observable<T>;
+		catchException<T>(...sources: Observable<T>[]): Observable<T>;
+		concat<T>(...sources: Observable<T>[]): Observable<T>;
+		concat<T>(sources: Observable<T>[]): Observable<T>;
+		merge<T>(...sources: Observable<T>[]): Observable<T>;
+		merge<T>(sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
+		zip<T, TResult>(sources: Observable<T>[], resultSelector: (...items: T[]) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<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, 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, 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[]>;
 	}
 
-	interface ICheckedObserver<T> extends IObserver<T> {
-		_observer: IObserver<T>;
-		_state: number; // 0 - idle, 1 - busy, 2 - done
-		checkAccess(): void;
-	}
+	export var Observable: ObservableStatic;
 
-	export module Internals {
-		interface IScheduledObserver<T> extends IAbstractObserver<T> {
-			scheduler: IScheduler;
-			observer: IObserver<T>;
-			isAcquired: boolean;
-			hasFaulted: boolean;
-			//queue: { (value: any): void; (exception: any): void; (): void; }[];
-			disposable: SerialDisposable;
-
-			ensureActive(): void;
-		}
-		export interface ScheduledObserver<T> {
-			(scheduler: IScheduler, observer: IObserver<T>): IScheduledObserver<T>;
-		}
-	}
-
-	interface IObservable<T> {
-		_subscribe: (observer: IObserver<T>) =>IDisposable;
-
-		subscribe(observer: IObserver<T>): IDisposable;
-
-		finalValue(): IObservable<T>;
-		subscribe(onNext?: (value: T) =>void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IDisposable;
-		toArray(): IObservable<T>;
-
-		observeOn(scheduler: IScheduler): IObservable<T>;
-		subscribeOn(scheduler: IScheduler): IObservable<T>;
-
-		amb(rightSource: IObservable<T>): IObservable<T>;
-		catchException(handler: (exception: any) =>IObservable<T>): IObservable<T>;
-		catchException(second: IObservable<T>): IObservable<T>;
-		combineLatest<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
-		combineLatest<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) =>TResult): IObservable<TResult>;
-		combineLatest<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) =>TResult): IObservable<TResult>;
-		combineLatest<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) =>TResult): IObservable<TResult>;
-		combineLatest<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
-		concat(...sources: IObservable<T>[]): IObservable<T>;
-		concat(sources: IObservable<T>[]): IObservable<T>;
-		//concatIObservable(): IObservable<T>;
-		merge(maxConcurrent: number): IObservable<T>;
-		merge(other: IObservable<T>): IObservable<T>;
-		//mergeIObservable(): IObservable<any>;
-		onErrorResumeNext(second: IObservable<T>): IObservable<T>;
-		skipUntil<T2>(other: IObservable<T2>): IObservable<T>;
-		switchLatest(): IObservable<T>;
-		takeUntil<T2>(other: IObservable<T2>): IObservable<T>;
-		zip<T2, TResult>(second: IObservable<T2>, resultSelector: (v1: T, v2: T2) =>TResult): IObservable<TResult>;
-		zip<T2, T3, TResult>(second: IObservable<T2>, third: IObservable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): IObservable<TResult>;
-		zip<T2, T3, T4, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): IObservable<TResult>;
-		zip<T2, T3, T4, T5, TResult>(second: IObservable<T2>, third: IObservable<T3>, fourth: IObservable<T4>, fifth: IObservable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): IObservable<TResult>;
-		zip<TResult>(...soucesAndResultSelector: any[]): IObservable<TResult>;
-		zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): IObservable<TResult>;
-		asIObservable(): IObservable<any>;
-		bufferWithCount(count: number, skip?: number): IObservable<T>;
-		dematerialize<TOrigin>(): IObservable<TOrigin>;
-		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) =>boolean): IObservable<any>;
-		doAction(observer: IObserver<T>): IObservable<T>;
-		doAction(onNext: (value: T) => void , onError?: (exception: any) =>void , onCompleted?: () =>void ): IObservable<T>;
-		finallyAction(action: () =>void): IObservable<T>;
-		ignoreElements(): IObservable<T>;
-		materialize(): IObservable<INotification<any>>; // IObservable<INotification<T>> not supported by TypeScript 0.9.0 !!
-		repeat(repeatCount?: number): IObservable<T>;
-		retry(retryCount?: number): IObservable<T>;
-		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
-		scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): IObservable<TAcc>;
-		skipLast(count: number): IObservable<T>;
-		startWith(...values: T[]): IObservable<T>;
-		startWith(scheduler: IScheduler, ...values: T[]): IObservable<T>;
-		takeLast(count: number, scheduler?: IScheduler): IObservable<T>;
-		takeLastBuffer(count: number): IObservable<T>;
-		windowWithCount(count: number, skip?: number): IObservable<T>;
-		defaultIfEmpty(defaultValue?: any): IObservable<T>;
-		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) =>string): IObservable<T>;
-		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
-		groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: IGroupedObservable<TKey, TElement>) => IObservable<number>, keySerializer?: (key: TKey) => string): IGroupedObservable<TKey, TElement>;
-		select<T2>(selector: (value: T, index: number) =>T2): IObservable<T2>;
-		selectMany<T2>(selector: (value: T) =>IObservable<T2>, resultSelector?: (x: any, y: any) =>any): IObservable<T2>;
-		selectMany<T2>(other: IObservable<T2>): IObservable<T2>;
-		skip(count: number): IObservable<T>;
-		skipWhile(predicate: (value: T, index?: number) =>boolean): IObservable<T>;
-		take(count: number, scheduler?: IScheduler): IObservable<T>;
-		takeWhile(predicate: (value: T, index?: number) =>boolean): IObservable<T>;
-		where(predicate: (value: T, index?: number) => boolean): IObservable<T>;
-	}
-
-	interface Observable {
-		(subscribe: (observer: IObserver<any>) =>IDisposable): IObservable<any>;
-
-		create<T>(subscribe: (observer: IObserver<T>) => void ): IObservable<T>;
-		create<T>(subscribe: (observer: IObserver<T>) => () => void ): IObservable<T>;
-		createWithDisposable<T>(subscribe: (observer: IObserver<T>) =>IDisposable): IObservable<T>;
-		defer<T>(observableFactory: () => IObservable<T>): IObservable<T>;
-		empty<T>(scheduler?: IScheduler): IObservable<T>;
-		fromArray<T>(array: T[], scheduler?: IScheduler): IObservable<T>;
-		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): IObservable<T>;
-		generate<TState, TResult>(initialState: TState, condition: (state: TState) => boolean, iterate: (state: TState) => TState, resultSelector: (state: TState) => TResult, scheduler?: IScheduler): IObservable<TResult>;
-		never<T>(): IObservable<T>;
-		range(start: number, count: number, scheduler?: IScheduler): IObservable<number>;
-		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): IObservable<T>;
-		return<T>(value: T, scheduler?: IScheduler): IObservable<T>;
-		returnValue<T>(value: T, scheduler?: IScheduler): IObservable<T>;
-		throw<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
-		throw<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
-		throwException<T>(exception: Error, scheduler?: IScheduler): IObservable<T>;
-		throwException<T>(exception: any, scheduler?: IScheduler): IObservable<T>;
-		using<TSource, TResource>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => IObservable<TSource>): IObservable<TSource>;
-		amb<T>(...sources: IObservable<T>[]): IObservable<T>;
-		catchException<T>(sources: IObservable<T>[]): IObservable<T>;
-		catchException<T>(...sources: IObservable<T>[]): IObservable<T>;
-		concat<T>(...sources: IObservable<T>[]): IObservable<T>;
-		concat<T>(sources: IObservable<T>[]): IObservable<T>;
-		merge<T>(...sources: IObservable<T>[]): IObservable<T>;
-		merge<T>(sources: IObservable<T>[]): IObservable<T>;
-		merge<T>(scheduler: IScheduler, ...sources: IObservable<T>[]): IObservable<T>;
-		merge<T>(scheduler: IScheduler, sources: IObservable<T>[]): IObservable<T>;
-		onErrorResumeNext<T>(...sources: IObservable<T>[]): IObservable<T>;
-		onErrorResumeNext<T>(sources: IObservable<T>[]): IObservable<T>;
-		zip<T>(...soucesAndResultSelector: any[]): IObservable<T>;
-	}
-
-	var Observable: Observable;
-
-	export module Internals {
-		interface IAnonymousObservable<T> extends IObservable<T> { }
-		export interface AnonymousObservable<T> {
-			(subscribe: (observer: IObserver<T>) =>IDisposable): IAnonymousObservable<T>;
-		}
-	}
-
-	interface IGroupedObservable<TKey, TElement> extends IObservable<TElement> {
+	interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
 		key: TKey;
-		underlyingObservable: IObservable<TElement>;
+		underlyingObservable: Observable<TElement>;
 	}
 
-	interface ISubject<T> extends IObservable<T>, IObserver<T> {
-		isDisposed: boolean;
-		isStopped: boolean;
-		//observers: IObserver<T>[];
-
-		dispose(): void;
+	interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
+		hasObservers(): boolean;
 	}
 
     export interface Subject<T> extends ISubject<T> {
-        create<T>(observer?: IObserver<T>, observable?: IObservable<T>): ISubject<T>;
     }
 
-    var Subject: {
+    interface SubjectStatic {
         new <T>(): Subject<T>;
-    }
-
-	interface IAsyncSubject<T> extends IObservable<T>, IObserver<T> {
-		isDisposed: boolean;
-		value: T;
-		hasValue: boolean;
-		observers: IObserver<T>[];
-		exception: any;
-
-		dispose(): void;
-	}
-	export interface AsyncSubject<T> {
-		(): IAsyncSubject<T>;
+		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
 	}
 
-	interface IAnonymousSubject<T> extends IObservable<T> {
-		onNext(value: T): void;
-		onError(exception: any): void;
-		onCompleted(): void;
+	export var Subject: SubjectStatic;
+
+	export interface AsyncSubject<T> extends Subject<T> {
 	}
+
+	interface AsyncSubjectStatic {
+		new <T>(): AsyncSubject<T>;
+	}
+
+	export var AsyncSubject: AsyncSubjectStatic;
+
+	export interface BehaviorSubject<T> extends Subject<T> {
+	}
+
+	interface BehaviorSubjectStatic {
+		new <T>(initialValue: T): BehaviorSubject<T>;
+	}
+
+	export var BehaviorSubject: BehaviorSubjectStatic;
+
+	export interface ReplaySubject<T> extends Subject<T> {
+	}
+
+	interface ReplaySubjectStatic {
+		new <T>(initialValue: T): ReplaySubject<T>;
+	}
+
+	export var ReplaySubject: ReplaySubjectStatic;
 }
diff --git a/rx.js/rx.js.experimental.d.ts b/rx.js/rx.js.experimental.d.ts
index a43788b87..1a1c38f54 100644
--- a/rx.js/rx.js.experimental.d.ts
+++ b/rx.js/rx.js.experimental.d.ts
@@ -7,7 +7,7 @@
 
 declare module Rx {
 
-	interface IObservable<T> {
+	interface Observable<T> {
 		/**
 		 *  Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
 		 *  This operator allows for a fluent style of writing queries that use the same sequence multiple times.
@@ -15,7 +15,7 @@ declare module Rx {
 		 * @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
 		 * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
 		 */
-		let<TResult>(selector: (source: IObservable<T>) => IObservable<TResult>): IObservable<TResult>;
+		let<TResult>(selector: (source: Observable<T>) => Observable<TResult>): Observable<TResult>;
 
 		/**
 		 *  Returns an observable sequence that is the result of invoking the selector on the source sequence, without sharing subscriptions.
@@ -24,14 +24,14 @@ declare module Rx {
 		 * @param selector Selector function which can use the source sequence as many times as needed, without sharing subscriptions to the source sequence.
 		 * @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence within a selector function.
 		 */
-		letBind<TResult>(selector: (source: IObservable<T>) => IObservable<TResult>): IObservable<TResult>;
+		letBind<TResult>(selector: (source: Observable<T>) => Observable<TResult>): Observable<TResult>;
 
 		/**
 		 *  Repeats source as long as condition holds emulating a do while loop.
 		 * @param condition The condition which determines if the source will be repeated.
 		 * @returns An observable sequence which is repeated as long as the condition holds. 
 		 */
-		doWhile(condition: () => boolean): IObservable<T>;
+		doWhile(condition: () => boolean): Observable<T>;
 
 		/**
 		 *  Expands an observable sequence by recursively invoking selector.
@@ -40,7 +40,7 @@ declare module Rx {
 		 * @param [scheduler] Scheduler on which to perform the expansion. If not provided, this defaults to the current thread scheduler.
 		 * @returns An observable sequence containing all the elements produced by the recursive expansion.
 		 */
-		expand(selector: (item: T) => IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+		expand(selector: (item: T) => Observable<T>, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Runs two observable sequences in parallel and combines their last elemenets.
@@ -49,7 +49,7 @@ declare module Rx {
 		 * @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: IObservable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): IObservable<TResult>;
+		forkJoin<TSecond, TResult>(second: Observable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
 
 		/**
 		 * Comonadic bind operator.
@@ -57,7 +57,7 @@ declare module Rx {
 		 * @param [scheduler] Scheduler used to execute the operation. If not specified, defaults to the ImmediateScheduler.
 		 * @returns An observable sequence which results from the comonadic bind operation.
 		 */
-		manySelect<TResult>(selector: (item: IObservable<T>, index: number, source: IObservable<T>) => TResult, scheduler?: IScheduler): IObservable<TResult>;
+		manySelect<TResult>(selector: (item: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
 	}
 
 	interface Observable {
@@ -71,7 +71,7 @@ declare module Rx {
 		 * @param elseSource The observable sequence 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: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
+		if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -83,7 +83,7 @@ declare module Rx {
 		 * @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: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+		if<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -95,7 +95,7 @@ declare module Rx {
 		 * @param elseSource The observable sequence 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: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
@@ -107,7 +107,7 @@ declare module Rx {
 		 * @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: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
@@ -116,7 +116,7 @@ declare module Rx {
 		 * @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
 		 * @returns An observable sequence from the concatenated observable sequences.  
 		 */
-		for<T, TResult>(sources: T[], resultSelector: (item: T) => IObservable<TResult>): IObservable<TResult>;
+		for<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
 
 		/**
 		 *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
@@ -125,7 +125,7 @@ declare module Rx {
 		 * @param resultSelector A function to apply to each item in the sources array to turn it into an observable sequence.
 		 * @returns An observable sequence from the concatenated observable sequences.  
 		 */
-		forIn<T, TResult>(sources: T[], resultSelector: (item: T) => IObservable<TResult>): IObservable<TResult>;
+		forIn<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
 
 		/**
 		 *  Repeats source as long as condition holds emulating a while loop.
@@ -134,7 +134,7 @@ declare module Rx {
 		 * @param source The observable sequence 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: IObservable<T>): IObservable<T>;
+		while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
 
 		/**
 		 *  Repeats source as long as condition holds emulating a while loop.
@@ -143,7 +143,7 @@ declare module Rx {
 		 * @param source The observable sequence 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: IObservable<T>): IObservable<T>;
+		whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -157,7 +157,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		case<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -173,7 +173,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		case<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -187,7 +187,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		case<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -203,7 +203,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		case<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -217,7 +217,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		switchCase<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -233,7 +233,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		switchCase<T>(selector: () => string, sources: { [key: string]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -247,7 +247,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		switchCase<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, elseSource: IObservable<T>): IObservable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 
 		/**
 		 *  Uses selector to determine which source in sources to use.
@@ -263,7 +263,7 @@ declare module Rx {
 		 *       
 		 * @returns An observable sequence which is determined by a case statement.  
 		 */
-		switchCase<T>(selector: () => number, sources: { [key: number]: IObservable<T>; }, scheduler?: IScheduler): IObservable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
@@ -273,7 +273,7 @@ declare module Rx {
 		 * @param sources Array of source sequences.
 		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
 		 */
-		forkJoin<T>(sources: IObservable<T>[]): IObservable<T[]>;
+		forkJoin<T>(sources: Observable<T>[]): Observable<T[]>;
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
@@ -283,6 +283,6 @@ declare module Rx {
 		 * @param args Source sequences.
 		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
 		 */
-		forkJoin<T>(...args: IObservable<T>[]): IObservable<T[]>;
+		forkJoin<T>(...args: Observable<T>[]): Observable<T[]>;
 	}
 }
diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.js.joinpatterns.d.ts
index a62b1914d..fe6cf6bdd 100644
--- a/rx.js/rx.js.joinpatterns.d.ts
+++ b/rx.js/rx.js.joinpatterns.d.ts
@@ -11,7 +11,7 @@
 
 declare module Rx {
 
-	//interface IObservable<T> {
+	//interface Observable<T> {
 	//}
 
 
diff --git a/rx.js/rx.js.jquery.d.ts b/rx.js/rx.js.jquery.d.ts
index bfd514631..75db935a9 100644
--- a/rx.js/rx.js.jquery.d.ts
+++ b/rx.js/rx.js.jquery.d.ts
@@ -55,45 +55,45 @@ declare module JQueryResults {
 
 
 interface JQueryStatic {
-	ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.IObservable<T>;
-	getAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
-	getJSONAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
-	getScriptAsObservable<T>(url: string, data: any): Rx.IObservable<T>;
-	postAsObservable<T>(url: string, data: any, dataType: string): Rx.IObservable<T>;
+	ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.Observable<T>;
+	getAsObservable<T>(url: string, data: any, dataType: string): Rx.Observable<T>;
+	getJSONAsObservable<T>(url: string, data: any): Rx.Observable<T>;
+	getScriptAsObservable<T>(url: string, data: any): Rx.Observable<T>;
+	postAsObservable<T>(url: string, data: any, dataType: string): Rx.Observable<T>;
 }
 
 interface JQuery {
-	changeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	clickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	dblclickAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	focusAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	focusinAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	focusoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	keydownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
-	keyupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.keyEvent>;
-	loadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.uiEvent>;
-	mousedownAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mouseenterAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mouseleaveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mousemoveAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mouseoutAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mouseoverAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	mouseupAsObservable(eventData?: any): Rx.IObservable<JQueryResults.mouseEvent>;
-	resizeAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	scrollAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	selectAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	submitAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	unloadAsObservable(eventData?: any): Rx.IObservable<JQueryResults.eventBase>;
-	hideAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
-	showAsObservable(duration: number): Rx.IObservable<JQueryResults.eventBase>;
-	readyAsObservable(): Rx.IObservable<any>;
-	animateAsObservable(properties: any, duration: number, easing?: string): Rx.IObservable<any>;
-	fadeInAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
-	fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.IObservable<any>;
-	fadeOutAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
-	fadeToggleAsObservable(duration: number, easing?: string): Rx.IObservable<any>;
-	slideDownAsObservable(duration: number): Rx.IObservable<any>;
-	slideUpAsObservable(duration: number): Rx.IObservable<any>;
-	slideToggleAsObservable(duration: number): Rx.IObservable<any>;
-	toggleAsObservable(duration: number): Rx.IObservable<any>;
+	changeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	clickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	dblclickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	focusAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	focusinAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	focusoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	keydownAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
+	keyupAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
+	loadAsObservable(eventData?: any): Rx.Observable<JQueryResults.uiEvent>;
+	mousedownAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mouseenterAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mouseleaveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mousemoveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mouseoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mouseoverAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	mouseupAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
+	resizeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	scrollAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	selectAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	submitAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	unloadAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
+	hideAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
+	showAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
+	readyAsObservable(): Rx.Observable<any>;
+	animateAsObservable(properties: any, duration: number, easing?: string): Rx.Observable<any>;
+	fadeInAsObservable(duration: number, easing?: string): Rx.Observable<any>;
+	fadeToAsObservable(duration: number, opacity: number, easing?: string): Rx.Observable<any>;
+	fadeOutAsObservable(duration: number, easing?: string): Rx.Observable<any>;
+	fadeToggleAsObservable(duration: number, easing?: string): Rx.Observable<any>;
+	slideDownAsObservable(duration: number): Rx.Observable<any>;
+	slideUpAsObservable(duration: number): Rx.Observable<any>;
+	slideToggleAsObservable(duration: number): Rx.Observable<any>;
+	toggleAsObservable(duration: number): Rx.Observable<any>;
 }
\ No newline at end of file
diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts
index e329a823c..779a7b3c9 100644
--- a/rx.js/rx.js.time.d.ts
+++ b/rx.js/rx.js.time.d.ts
@@ -11,61 +11,61 @@
 
 declare module Rx {
 
-	interface ITimeInterval {
-		value: any;
+	export interface TimeInterval<T> {
+		value: T;
 		interval: number;
 	}
 
-	interface ITimestamp {
-		value: any;
-		interval: number;
+	export interface Timestamp<T> {
+		value: T;
+		timestamp: number;
 	}
 
-	interface IObservable<T> {
-		ifThen(condition: () => boolean, thenSource: IObservable<T>): IObservable<T>;
-		ifThen(condition: () => boolean, thenSource: IObservable<T>, elseSource: IObservable<T>): IObservable<T>;
-		ifThen(condition: () => boolean, thenSource: IObservable<T>, scheduler: IScheduler): IObservable<T>;
+	export interface Observable<T> {
+		ifThen(condition: () => boolean, thenSource: Observable<T>): Observable<T>;
+		ifThen(condition: () => boolean, thenSource: Observable<T>, elseSource: Observable<T>): Observable<T>;
+		ifThen(condition: () => boolean, thenSource: Observable<T>, scheduler: IScheduler): Observable<T>;
 
-		delay(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		throttle(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
-		windowWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
-		windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
-		bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): IObservable<T>;
-		bufferWithTime(timeSpan: number, scheduler?: IScheduler): IObservable<T>;
-		bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): IObservable<T>;
-		timeInterval(scheduler?: IScheduler): IObservable<ITimeInterval>;
-		timestamp(scheduler?: IScheduler): IObservable<ITimestamp>;
-		sample(interval: number, scheduler?: IScheduler): IObservable<T>;
-		sample<TSample>(sampler: IObservable<TSample>, scheduler?: IScheduler): IObservable<T>;
-		timeout(dueTime: Date, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
-		timeout(dueTime: number, other?: IObservable<T>, scheduler?: IScheduler): IObservable<T>;
+		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<T>;
+		windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable<T>;
+		windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<T>;
+		bufferWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<T>;
+		bufferWithTime(timeSpan: number, scheduler?: IScheduler): Observable<T>;
+		bufferWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<T>;
+		timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
+		timestamp(scheduler?: IScheduler): Observable<Timestamp<T>>;
+		sample(interval: number, scheduler?: IScheduler): Observable<T>;
+		sample<TSample>(sampler: Observable<TSample>, scheduler?: IScheduler): Observable<T>;
+		timeout(dueTime: Date, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		timeout(dueTime: number, other?: Observable<T>, scheduler?: IScheduler): Observable<T>;
 
-		delaySubscription(dueTime: number, scheduler?: IScheduler): IObservable<T>;
-		delayWithSelector(delayDurationSelector: (item: T) => number): IObservable<T>;
-		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): IObservable<T>;
+		delaySubscription(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
+		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<T>;
 
-		timeoutWithSelector<TTimeout>(firstTimeout: IObservable<TTimeout>, timeoutdurationSelector?: (item: T) => IObservable<TTimeout>, other?: IObservable<T>): IObservable<T>;
-		throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => IObservable<TTimeout>): IObservable<T>;
+		timeoutWithSelector<TTimeout>(firstTimeout: Observable<TTimeout>, timeoutdurationSelector?: (item: T) => Observable<TTimeout>, other?: Observable<T>): Observable<T>;
+		throttleWithSelector<TTimeout>(throttleDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
 
-		skipLastWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
-		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): IObservable<T>;
+		skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
 
-		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): IObservable<T[]>;
-		takeWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
-		skipWithTime(duration: number, scheduler?: IScheduler): IObservable<T>;
+		takeLastBufferWithTime(duration: number, scheduler?: IScheduler): Observable<T[]>;
+		takeWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+		skipWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
 
-		skipUntilWithTime(startTime: Date, scheduler?: IScheduler): IObservable<T>;
-		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): IObservable<T>;
+		skipUntilWithTime(startTime: Date, scheduler?: IScheduler): Observable<T>;
+		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
 	}
 
-	interface Observable {
-		interval(period: number, scheduler?: IScheduler): IObservable<number>;
-		interval(dutTime: number, period: number, scheduler?: IScheduler): IObservable<number>;
-		timer(dueTime: Date, period: number, scheduler: IScheduler): IObservable<number>;
-		timer(dueTime: Date, scheduler: IScheduler): IObservable<number>;
-		timer(dueTime: number, period: number, scheduler: IScheduler): IObservable<number>;
-		timer(dueTime: number, scheduler: IScheduler): IObservable<number>;
+	interface ObservableStatic {
+		interval(period: number, scheduler?: IScheduler): Observable<number>;
+		interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
+		timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: number, period: number, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: number, scheduler: IScheduler): Observable<number>;
 
 		generateWithAbsoluteTime<TState, TResult>(
 			initialState: TState,
@@ -73,7 +73,7 @@ declare module Rx {
 			iterate: (state: TState) => TState,
 			resultSelector: (state: TState) => TResult,
 			timeSelector: (state: TState) => Date,
-			scheduler?: IScheduler): IObservable<TResult>;
+			scheduler?: IScheduler): Observable<TResult>;
 
 		generateWithRelativeTime<TState, TResult>(
 			initialState: TState,
@@ -81,6 +81,6 @@ declare module Rx {
 			iterate: (state: TState) => TState,
 			resultSelector: (state: TState) => TResult,
 			timeSelector: (state: TState) => number,
-			scheduler?: IScheduler): IObservable<TResult>;
+			scheduler?: IScheduler): Observable<TResult>;
 	}
 }
\ No newline at end of file

From 36513cf85fbbabf7d0fdb53b230392720654dbc2 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sat, 14 Dec 2013 17:18:44 +0400
Subject: [PATCH 04/22] rx.js.d.ts: updated many of Observable methods added
 tests for Observable instance methods

---
 rx.js/rx-tests.ts | 162 +++++++++++++++++++++++++++++++++++++++++++---
 rx.js/rx.js.d.ts  |  85 +++++++++++++-----------
 2 files changed, 202 insertions(+), 45 deletions(-)

diff --git a/rx.js/rx-tests.ts b/rx.js/rx-tests.ts
index 14388c49f..d95988ce6 100644
--- a/rx.js/rx-tests.ts
+++ b/rx.js/rx-tests.ts
@@ -108,28 +108,174 @@ bs = Rx.Observable.throwException<boolean>(new Error("error"), Rx.Scheduler.time
 bs = Rx.Observable.using(() => d, d => Rx.Observable.return(true));
 
 ss = Rx.Observable.amb(ss, ss);
-//ss = Rx.Observable.amb([ss, ss]);
+//ss = Rx.Observable.amb([ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 
 ss = Rx.Observable.catch(ss, ss, ss);
 ss = Rx.Observable.catchException(ss, ss, ss);
-//ss = Rx.Observable.catch([ss, ss, ss]);
-//ss = Rx.Observable.catchException([ss, ss, ss]);
+//ss = Rx.Observable.catch([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
+//ss = Rx.Observable.catchException([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 
 ss = Rx.Observable.concat(ss, ss, ss);
-//ss = Rx.Observable.concat([ss, ss, ss]);
+//ss = Rx.Observable.concat([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 
 ss = Rx.Observable.merge(ss, ss, ss);
-//ss = Rx.Observable.merge([ss, ss, ss]);
+//ss = Rx.Observable.merge([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 ss = Rx.Observable.merge(s, ss, ss, ss);
-//ss = Rx.Observable.merge(s, [ss, ss, ss]);
+//ss = Rx.Observable.merge(s, [ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 
 ss = Rx.Observable.onErrorResumeNext(ss, ss, ss);
-//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);
+//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
 
+ns = Rx.Observable.zip(ss, [ss, ss, ss], (s, ss2) => { ss = ss2; return s.charCodeAt(0); });
+ns = Rx.Observable.zip(ss, bs, (s, b) => s.length + (b ? 1 : 0));
 ns = Rx.Observable.zip(ss, bs, ns, (s, b, n) => s.length + (b ? 1 : 0) + n);
+ns = Rx.Observable.zip(ss, bs, ns, ns, (s, b, n, n2) => s.length + (b ? 1 : 0) + n + n2);
+ns = Rx.Observable.zip(ss, bs, ns, ns, ss, (s, b, n, n2, s2) => s.length + (b ? 1 : 0) + n + n2 + s2.charCodeAt(0));
+
+var sas: Rx.Observable<string[]> = Rx.Observable.zipArray(ss, ss);
 
 
 // Observable instance methods
 
+d = ns.subscribe(o);
+d = ns.subscribe(n => n + 1, err => { }, () => { });
+d = ns.subscribe(n => n + 1, err => { });
+d = ns.subscribe();
+
+sas = ss.toArray();
+
+ss.observeOn(s);
+ns.subscribeOn(s);
+
+ss = ss.amb(ss);
+
+ss = ss.catch(err => ss);
+ss = ss.catchException(err => ss);
+ss = ss.catch(ss);
+ss = ss.catchException(ss);
+
+ns = ss.combineLatest([ns, ns, ns], (s, ...ns) => s.charCodeAt(0) + ns[0]);
+ns = ss.combineLatest(ns, (s, n) => s.charCodeAt(0) + n);
+ns = ss.combineLatest(ns, ns, (s, n, n2) => s.charCodeAt(0) + n + n2);
+ns = ss.combineLatest(ns, ns, bs, (s, n, n2, b) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0));
+ns = ss.combineLatest(ns, ns, bs, ss, (s, n, n2, b, s2) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0) + s2.charCodeAt(0));
+
+ss = ss.concat(ss, ss);
+ss = ss.concat([ss, ss]);
+
 var sss: Rx.Observable<Rx.Observable<string>>;
-ss = sss.concatAll();
\ No newline at end of file
+ss = sss.concatAll();
+ss = sss.concatObservable();
+
+ss = ss.merge(2);
+ss = ss.merge(ss);
+
+ss = sss.mergeAll();
+ss = sss.mergeObservable();
+
+ss = ss.onErrorResumeNext(ss);
+
+ss = ss.skipUntil(ns);
+
+ss = ss.takeUntil(ns);
+
+ss = sss.switchLatest();
+
+ns = ss.zip([ns, ns], (s, ns2) => { ns = ns2; return s.charCodeAt(0); });
+
+ns = ss.zip(ns, (s, n) => s.charCodeAt(0) + n);
+ns = ss.zip(ns, bs, (s, n, b) => s.charCodeAt(0) + n + (b?1:0));
+ns = ss.zip(ns, bs, ss, (s, n, b, s2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0));
+ns = ss.zip(ns, bs, ss, ns, (s, n, b, s2, n2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0) + n2);
+
+ss = ss.asObservable();
+
+sas = ss.bufferWithCount(2);
+sas = ss.bufferWithCount(2, 1);
+
+var notifications: Rx.Observable<Rx.Notification<number>>;
+
+ns = notifications.dematerialize<number>();
+
+ns = ns.distinctUntilChanged();
+ns = ns.distinctUntilChanged(n => (n + 1).toString());
+ns = ns.distinctUntilChanged(n => (n + 1).toString(), (s1, s2) => s1.charCodeAt(0) === s2.charCodeAt(0));
+ns = ns.distinctUntilChanged(undefined, (n1, n2) => (n1 + 1) === (n2 + 1));
+
+ns = ns.do(o);
+ns = ns.doAction(o);
+ns = ns.do(n => n + 1, err => { }, () => { });
+ns = ns.doAction(n => n + 1, err => { }, () => { });
+ns = ns.do(n => n + 1, err => { });
+ns = ns.doAction(n => n + 1, err => { });
+ns = ns.do();
+ns = ns.doAction();
+
+ns = ns.finally(() => { });
+ns = ns.finallyAction(() => { });
+
+ss = ss.ignoreElements();
+
+notifications = ns.materialize();
+
+ss = ss.repeat();
+ss = ss.repeat(10);
+
+ss = ss.retry();
+ss = ss.retry(10);
+
+ns = ss.scan(0, (sum, s) => sum + s.charCodeAt(0));
+ns = ns.scan((sum, n) => sum + n);
+
+ns = ns.skipLast(10);
+
+ns = ns.startWith(10, 20);
+ns = ns.startWith(s, 10, 20);
+
+ns = ns.takeLast(2);
+ns = ns.takeLast(2, s);
+
+sas = ss.takeLastBuffer(5);
+
+sss = ss.windowWithCount(2);
+sss = ss.windowWithCount(2, 3);
+
+ns = ns.defaultIfEmpty();
+ns = ns.defaultIfEmpty(0);
+
+ns = ns.distinct(n => (n + 1), n => (n + 1).toString());
+ns = ns.distinct(undefined, n => (n + 1).toString());
+ns = ns.distinct(n => (n + 1).toString());
+ns = ns.distinct();
+
+var gnss: Observable<GroupedObservable<number, string>>;
+var group: GroupedObservable<number, string>;
+ss = group;
+n = group.key;
+
+gnss = ss.groupBy(s => s.charCodeAt(0));
+gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!");
+gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!", k => (k + 1).toString());
+gnss = ss.groupBy(s => s.charCodeAt(0), undefined, k => (k + 1).toString());
+
+gnss = ss.groupByUntil(s => s.charCodeAt(0), s => s + "!", g => ns, k => (k + 1).toString());
+gnss = ss.groupByUntil(s => s.charCodeAt(0), undefined, g => ns, k => (k + 1).toString());
+
+ns = ss.select(s => s.charCodeAt(0), ns);
+ns = ss.map(s => s.charCodeAt(0), ns);
+ns = ss.select(s => s.charCodeAt(0));
+ns = ss.map(s => s.charCodeAt(0));
+ns = ss.select((s, index) => s.charCodeAt(0) + index);
+ns = ss.map((s, index) => s.charCodeAt(0) + index);
+ns = ss.select((s, index) => s.charCodeAt(0) + index, ns);
+ns = ss.map((s, index) => s.charCodeAt(0) + index, ns);
+ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
+ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
+ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
+ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
+
+ss = ss.selectMany(s => ns, (s, n) => s + n.toString());
+ns = ss.selectMany(s => ns);
+ns = ss.selectMany(ns);
+
+ns = ns.skip(10);
diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts
index 7107afb1e..84ea91332 100644
--- a/rx.js/rx.js.d.ts
+++ b/rx.js/rx.js.d.ts
@@ -203,74 +203,85 @@ declare module Rx {
 	}
 
 	export interface Observable<T> {
-		_subscribe: (observer: Observer<T>) => IDisposable;
-
 		subscribe(observer: Observer<T>): IDisposable;
-
-		finalValue(): Observable<T>;
 		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
-		toArray(): Observable<T>;
+
+		toArray(): Observable<T[]>;
 
 		observeOn(scheduler: IScheduler): Observable<T>;
 		subscribeOn(scheduler: IScheduler): Observable<T>;
 
 		amb(rightSource: Observable<T>): Observable<T>;
-		catchException(handler: (exception: any) => Observable<T>): Observable<T>;
-		catchException(second: Observable<T>): Observable<T>;
+		catch(handler: (exception: any) => Observable<T>): Observable<T>;
+		catchException(handler: (exception: any) => Observable<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, T3, TResult>(second: Observable<T2>, third: Observable<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, 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<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
+		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
 		concat(...sources: Observable<T>[]): Observable<T>;
 		concat(sources: Observable<T>[]): Observable<T>;
-		concatObservable(): T;
 		concatAll(): T;
+		concatObservable(): T;	// alias for concatAll
 		merge(maxConcurrent: number): Observable<T>;
 		merge(other: Observable<T>): Observable<T>;
-		mergeObservable(): T;
 		mergeAll(): T;
+		mergeObservable(): T;	// alias for mergeAll
 		onErrorResumeNext(second: Observable<T>): Observable<T>;
 		skipUntil<T2>(other: Observable<T2>): Observable<T>;
-		switchLatest(): Observable<T>;
+		switchLatest(): T;
 		takeUntil<T2>(other: Observable<T2>): Observable<T>;
 		zip<T2, TResult>(second: Observable<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, 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, 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<TResult>(...soucesAndResultSelector: any[]): Observable<TResult>;
-		zip<TResult>(second: any[], resultSelector: (left: T, right: any) => TResult): Observable<TResult>;
-		asIObservable(): Observable<any>;
-		bufferWithCount(count: number, skip?: number): Observable<T>;
+		zip<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, right: Observable<TOther>) => TResult): Observable<TResult>;
+		asObservable(): Observable<T>;
+		bufferWithCount(count: number, skip?: number): Observable<T[]>;
 		dematerialize<TOrigin>(): Observable<TOrigin>;
-		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<any>;
-		doAction(observer: Observer<T>): Observable<T>;
-		doAction(onNext: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
-		finallyAction(action: () => void): Observable<T>;
+		distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
+		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
+		do(observer: Observer<T>): Observable<T>;
+		doAction(observer: Observer<T>): Observable<T>;	// alias for do
+		do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
+		doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
+		finally(action: () => void): Observable<T>;
+		finallyAction(action: () => void): Observable<T>;	// alias for finally
 		ignoreElements(): Observable<T>;
 		materialize(): Observable<Notification<T>>;
 		repeat(repeatCount?: number): Observable<T>;
 		retry(retryCount?: number): Observable<T>;
 		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
-		scan<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
 		skipLast(count: number): Observable<T>;
 		startWith(...values: T[]): Observable<T>;
 		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
 		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
-		takeLastBuffer(count: number): Observable<T>;
-		windowWithCount(count: number, skip?: number): Observable<T>;
+		takeLastBuffer(count: number): Observable<T[]>;
+		windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
 		defaultIfEmpty(defaultValue?: T): Observable<T>;
+		distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
 		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
-		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector?: (value: T) => TElement, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
-		groupByUntil<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<number>, keySerializer?: (key: TKey) => string): GroupedObservable<TKey, TElement>;
-		select<T2>(selector: (value: T, index: number) => T2): Observable<T2>;
-		selectMany<T2>(selector: (value: T) => Observable<T2>, resultSelector?: (x: any, y: any) => any): Observable<T2>;
-		selectMany<T2>(other: Observable<T2>): Observable<T2>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
+		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
+		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
+		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
+		flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;	// alias for selectMany
 		skip(count: number): Observable<T>;
-		skipWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
+		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		take(count: number, scheduler?: IScheduler): Observable<T>;
-		takeWhile(predicate: (value: T, index?: number) => boolean): Observable<T>;
-		where(predicate: (value: T, index?: number) => boolean): Observable<T>;
+		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
 	}
 
 	interface ObservableStatic {
@@ -286,18 +297,18 @@ declare module Rx {
 		range(start: number, count: number, scheduler?: IScheduler): Observable<number>;
 		repeat<T>(value: T, repeatCount?: number, scheduler?: IScheduler): Observable<T>;
 		return<T>(value: T, scheduler?: IScheduler): Observable<T>;
-		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;
+		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
 		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
 		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
-		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
-		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;
+		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
+		throwException<T>(exception: any, scheduler?: IScheduler): Observable<T>;	// alias for throw
 		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
 		amb<T>(...sources: Observable<T>[]): Observable<T>;
 		amb<T>(sources: Observable<T>[]): Observable<T>;
 		catch<T>(sources: Observable<T>[]): Observable<T>;
-		catchException<T>(sources: Observable<T>[]): Observable<T>;
+		catchException<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
 		catch<T>(...sources: Observable<T>[]): Observable<T>;
-		catchException<T>(...sources: Observable<T>[]): Observable<T>;
+		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
 		concat<T>(...sources: Observable<T>[]): Observable<T>;
 		concat<T>(sources: Observable<T>[]): Observable<T>;
 		merge<T>(...sources: Observable<T>[]): Observable<T>;
@@ -306,13 +317,13 @@ declare module Rx {
 		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
 		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
 		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
-		zip<T, TResult>(sources: Observable<T>[], resultSelector: (...items: T[]) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, right: Observable<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, 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, 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, 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[]>;
+		//zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
 	}
 
 	export var Observable: ObservableStatic;

From 9c2f13f04dd858a2bc59a469caac2da0326f02d4 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 11:21:23 +0400
Subject: [PATCH 05/22] rx.js.virtualtime.d.ts: updated names, added
 HistoricalScheduler rx.js.d.ts: updated names, moved some interfaces to
 Internal

---
 rx.js/rx.js.async.d.ts        |  7 +--
 rx.js/rx.js.binding.d.ts      | 43 ++++++++----------
 rx.js/rx.js.coincidence.d.ts  |  4 --
 rx.js/rx.js.d.ts              | 84 +++++++++++++----------------------
 rx.js/rx.js.experimental.d.ts |  2 +-
 rx.js/rx.js.virtualtime.d.ts  | 53 +++++++++++-----------
 6 files changed, 80 insertions(+), 113 deletions(-)

diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts
index fa336ac7e..49e1ec59b 100644
--- a/rx.js/rx.js.async.d.ts
+++ b/rx.js/rx.js.async.d.ts
@@ -3,14 +3,11 @@
 // Type definitions for RxJS-Async package 2.2
 // Project: http://rx.codeplex.com/
 // Definitions by: zoetrope <https://github.com/zoetrope>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.async.js
 
 declare module Rx {
-    interface Observable {
+    interface ObservableStatic {
         start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
         toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => Observable<T>;
         fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => Observable<T>;
diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.js.binding.d.ts
index 0921f30c5..0a749cc8e 100644
--- a/rx.js/rx.js.binding.d.ts
+++ b/rx.js/rx.js.binding.d.ts
@@ -3,41 +3,40 @@
 // Type definitions for RxJS-Binding package
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.binding.js
 
 declare module Rx {
-
-	interface ReplaySubject<T> extends ISubject<T> {
-		new (bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	export interface BehaviorSubject<T> extends Subject<T> {
 	}
 
-    var ReplaySubject: {
-        new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
-    }
-
-	interface BehaviorSubject<T> extends ISubject<T> {
-		new (initialValue: T): BehaviorSubject<any>;
+	interface BehaviorSubjectStatic {
+		new <T>(initialValue: T): BehaviorSubject<T>;
 	}
 
-    var BehaviorSubject: {
-        new <T>(initialValue: T): BehaviorSubject<T>;
-    }
+	export var BehaviorSubject: BehaviorSubjectStatic;
 
-	interface ConnectableObservable<T> extends Observable<T>{
+	export interface ReplaySubject<T> extends Subject<T> {
+	}
+
+	interface ReplaySubjectStatic {
+		new <T>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	}
+
+	export var ReplaySubject: ReplaySubjectStatic;
+
+	interface ConnectableObservable<T> extends Observable<T> {
 		connect(): IDisposable;
 		refCount(): Observable<T>;
     }
 
-    var ConnectableObservable: {
+    interface ConnectableObservableStatic {
         new <T>(): ConnectableObservable<T>;
-    }
+	}
 
-	interface Observable<T> {
+	export var ConnectableObservable: ConnectableObservableStatic;
 
+	export interface Observable<T> {
 		publish(): ConnectableObservable<T>;
 		publish<TResult>(selector: (item: T) => Observable<TResult>): ConnectableObservable<TResult>;
 		publishLast(): ConnectableObservable<T>;
@@ -47,8 +46,4 @@ declare module Rx {
 
 		replay(selector?: (source: Observable<T>) => ReplaySubject<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
 	}
-
-
-	interface Observable {
-	}
 }
diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts
index 7aa0ae65a..3ec1a3a25 100644
--- a/rx.js/rx.js.coincidence.d.ts
+++ b/rx.js/rx.js.coincidence.d.ts
@@ -33,8 +33,4 @@ declare module Rx {
 		window<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
 			bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
 	}
-
-
-	interface Observable {
-	}
 }
diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.js.d.ts
index 84ea91332..b2ad79a48 100644
--- a/rx.js/rx.js.d.ts
+++ b/rx.js/rx.js.d.ts
@@ -1,37 +1,49 @@
 // Type definitions for RxJS
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-
 declare module Rx {
 	export module Internals {
+		function isEqual(left: any, right: any): boolean;
 		function inherits(child: Function, parent: Function): Function;
 		function addProperties(obj: Object, ...sourcces: Object[]): void;
 		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
-	}
 
-	//Collections
-	interface IIndexedItem {
-		id: number;
-		value: IScheduledItem;
+		// Priority Queue for Scheduling
+		export class PriorityQueue<TTime> {
+			constructor(capacity: number);
 
-		compareTo(other: IIndexedItem): number;
-	}
+			length: number;
 
-	// Priority Queue for Scheduling
-	interface IPriorityQueue {
-		items: IIndexedItem[];
-		length: number;
+			isHigherPriority(left: number, right: number): boolean;
+			percolate(index: number): void;
+			heapify(index: number): void;
+			peek(): ScheduledItem<TTime>;
+			removeAt(index: number): void;
+			dequeue(): ScheduledItem<TTime>;
+			enqueue(item: ScheduledItem<TTime>): void;
+			remove(item: ScheduledItem<TTime>): boolean;
 
-		isHigherPriority(left: number, right: number): boolean;
-		percolate(index: number): void;
-		heapify(index: number): void;
-		peek(): IIndexedItem;
-		removeAt(index: number): void;
-		dequeue(): IIndexedItem;
-		enqueue(item: IIndexedItem): void;
-		remove(item: IIndexedItem): boolean;
+			static count: number;
+		}
+
+		export class ScheduledItem<TTime> {
+			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
+
+			scheduler: IScheduler;
+			state: TTime;
+			action: (scheduler: IScheduler, state: any) => IDisposable;
+			dueTime: TTime;
+			comparer: (x: TTime, y: TTime) => number;
+			disposable: SingleAssignmentDisposable;
+
+			invoke(): void;
+			compareTo(other: ScheduledItem<TTime>): number;
+			isCancelled(): boolean;
+			invokeCore(): IDisposable;
+		}
 	}
 
 	export interface IDisposable {
@@ -94,20 +106,6 @@ declare module Rx {
 		getDisposable(): IDisposable;
 	}
 
-	interface IScheduledItem {
-		scheduler: IScheduler;
-		state: any;
-		action: (scheduler: IScheduler, state) => IDisposable;
-		dueTime: number;
-		comparer: (x: number, y: number) =>number;
-		disposable: SingleAssignmentDisposable;
-
-		invoke(): void;
-		compareTo(other: IScheduledItem): number;
-		isCancelled(): boolean;
-		invokeCore(): IDisposable;
-	}
-
 	export interface IScheduler {
 		now(): number;
 		catch(handler: (exception: any) => boolean): IScheduler;
@@ -355,22 +353,4 @@ declare module Rx {
 	}
 
 	export var AsyncSubject: AsyncSubjectStatic;
-
-	export interface BehaviorSubject<T> extends Subject<T> {
-	}
-
-	interface BehaviorSubjectStatic {
-		new <T>(initialValue: T): BehaviorSubject<T>;
-	}
-
-	export var BehaviorSubject: BehaviorSubjectStatic;
-
-	export interface ReplaySubject<T> extends Subject<T> {
-	}
-
-	interface ReplaySubjectStatic {
-		new <T>(initialValue: T): ReplaySubject<T>;
-	}
-
-	export var ReplaySubject: ReplaySubjectStatic;
 }
diff --git a/rx.js/rx.js.experimental.d.ts b/rx.js/rx.js.experimental.d.ts
index 1a1c38f54..a1a7fbea3 100644
--- a/rx.js/rx.js.experimental.d.ts
+++ b/rx.js/rx.js.experimental.d.ts
@@ -60,7 +60,7 @@ declare module Rx {
 		manySelect<TResult>(selector: (item: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
 	}
 
-	interface Observable {
+	interface ObservableStatic {
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
 		 *  
diff --git a/rx.js/rx.js.virtualtime.d.ts b/rx.js/rx.js.virtualtime.d.ts
index 04b39acec..fe5d21689 100644
--- a/rx.js/rx.js.virtualtime.d.ts
+++ b/rx.js/rx.js.virtualtime.d.ts
@@ -3,35 +3,34 @@
 // Type definitions for RxJS-VirtualTime package 2.2
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.virtualtime.js
 
 declare module Rx {
     // Virtual IScheduler
-    interface IVirtualTimeScheduler extends IScheduler {
-        toRelative(duetime): number;
-        toDateTimeOffset(duetime: number): number;
+	export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
+		constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
 
-        clock: number;
-        comparer: (x: number, y: number) =>number;
-        isEnabled: boolean;
-        queue: IPriorityQueue;
-        scheduleRelativeWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
-        scheduleRelative(dueTime: number, action: () =>void ): IDisposable;
-        start(): IDisposable;
-        stop(): void;
-        advanceTo(time: number);
-        advanceBy(time: number);
-        sleep(time: number);
-        getNext(): IScheduledItem;
-        scheduleAbsolute(dueTime: number, action: () =>void );
-        scheduleAbsoluteWithState(state: any, dueTime: number, action: (scheduler: IScheduler, state: any) =>IDisposable): IDisposable;
-    }
-    //export module VirtualTimeScheduler {
-    //    //absract
-    //    function new (initialClock: number, comparer: (x: number, y: number) =>number): IVirtualTimeScheduler;
-    //}
-}
\ No newline at end of file
+		advanceBy(time: TRelative);
+		advanceTo(time: TAbsolute);
+		scheduleAbsolute(dueTime: TAbsolute, action: () => void);
+		scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
+		scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		sleep(time: TRelative);
+		start(): IDisposable;
+		stop(): void;
+
+		isEnabled: boolean;
+
+		/* protected abstract */ add(from: TAbsolute, by: TRelative): TAbsolute;
+		/* protected abstract */ toDateTimeOffset(duetime: TAbsolute): number;
+		/* protected abstract */ toRelative(duetime: number): TRelative;
+
+		/* protected */ getNext(): Internals.ScheduledItem<TAbsolute>;
+	}
+
+	export class HistoricalScheduler extends VirtualTimeScheduler<number, number> {
+		constructor(initialClock: number, comparer: (first: number, second: number) => number);
+	}
+}

From 8a8a3cf9bf08329f6e5fc5487b54fde5882fe3cf Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 11:49:09 +0400
Subject: [PATCH 06/22] Updated rx.js.aggregates.d.ts

---
 rx.js/rx.js.aggregates.d.ts | 60 +++++++++++++++++--------------------
 1 file changed, 28 insertions(+), 32 deletions(-)

diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts
index 1955bfe7f..4b2ed300b 100644
--- a/rx.js/rx.js.aggregates.d.ts
+++ b/rx.js/rx.js.aggregates.d.ts
@@ -3,51 +3,47 @@
 // Type definitions for RxJS-Aggregates package
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.aggregates.js
 
 declare module Rx {
 	export interface Observable<T> {
-		aggregate<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
 		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
 
-		any(): Observable<boolean>;
-		any(selector: (item: T) => boolean): Observable<boolean>;
+		any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
+		some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;	// alias for any
 
-		isEmpty(predicate?: (value: T) => boolean): Observable<boolean>;
-		all(predicate?: (value: T) => boolean): Observable<boolean>;
-		contains(value: T, comparer?: (value1: T, value2: T) => boolean): Observable<boolean>;
-		count(predicate?: (item: T) => boolean): Observable<number>;
-		sum(keySelector?: (item: T) => number): Observable<number>;
-		minBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		isEmpty(): Observable<boolean>;
+		all(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;
+		every(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;	// alias for all
+		contains(value: T): Observable<boolean>;
+		contains<TOther>(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable<boolean>;
+		count(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
+		sum(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
+		minBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		minBy(keySelector: (item: T) => number): Observable<T>;
 		min(comparer?: (value1: T, value2: T) => number): Observable<T>;
-		maxBy(keySelector: (item: T) => number, comparer?: (value1: T, value2: T) => number): Observable<T>;
+		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		maxBy(keySelector: (item: T) => number): Observable<T>;
 		max(comparer?: (value1: T, value2: T) => number): Observable<number>;
-		average(keySelector?: (item: T) => number): Observable<number>;
+		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(second: Observable<T>): Observable<boolean>;
+		sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual(second: T[]): Observable<boolean>;
 
-		sequenceEqual(second: Observable<T>, comparer?: (value1: T, value2: T) => number): Observable<T>;
 		elementAt(index: number): Observable<T>;
-		elementAtOrDefault(index: number, defaultValue: T): Observable<T>;
+		elementAtOrDefault(index: number, defaultValue?: T): Observable<T>;
 
-		single(): Observable<T>;
-		single(predicate: (item: T) => boolean): Observable<T>;
-		singleOrDefault(): Observable<T>;
-		singleOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		singleOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		single(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		singleOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 
-		first(): Observable<T>;
-		first(predicate: (item: T) => boolean): Observable<T>;
-		firstOrDefault(): Observable<T>;
-		firstOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		firstOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		first(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		firstOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 
-		last(): Observable<T>;
-		last(predicate: (item: T) => boolean): Observable<T>;
-		lastOrDefault(): Observable<T>;
-		lastOrDefault(predicate: (item: T) => boolean): Observable<T>;
-		lastOrDefault(predicate: (item: T) => boolean, defaultValue: T): Observable<T>;
+		last(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		lastOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
 	}
 }
\ No newline at end of file

From 6cd535fbbc4299530daf31f1fc64f154cf8a42fc Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 11:52:05 +0400
Subject: [PATCH 07/22] rx.js.aggregates.d.ts: added find, findIndex functions

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

diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts
index 4b2ed300b..36b87612e 100644
--- a/rx.js/rx.js.aggregates.d.ts
+++ b/rx.js/rx.js.aggregates.d.ts
@@ -45,5 +45,8 @@ declare module Rx {
 
 		last(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		lastOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
+
+		find(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		findIndex(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
 	}
-}
\ No newline at end of file
+}

From 18c862f14c6ac614360b93ef17dbcab1179aebfd Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 11:55:41 +0400
Subject: [PATCH 08/22] rx.js.aggregates.d.ts: added reduce function

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

diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.js.aggregates.d.ts
index 36b87612e..fcc368461 100644
--- a/rx.js/rx.js.aggregates.d.ts
+++ b/rx.js/rx.js.aggregates.d.ts
@@ -11,6 +11,9 @@ declare module Rx {
 		aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
 		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
 
+		reduce(accumulator: (acc: T, value: T) => T): Observable<T>;
+		reduce<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable<TAcc>;		// TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751
+
 		any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
 		some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;	// alias for any
 

From b5a1466ead9f73e44d582f2bbce8b6e0c44cbe08 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 21:16:51 +0400
Subject: [PATCH 09/22] updated rx.js.async.d.ts: created lot of typed
 overloads for toAsync, fromCallback, fromNodeCallback

---
 rx.js/rx.js.async.d.ts | 89 +++++++++++++++++++++++++++++++++++++-----
 1 file changed, 80 insertions(+), 9 deletions(-)

diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts
index 49e1ec59b..8adfeae4c 100644
--- a/rx.js/rx.js.async.d.ts
+++ b/rx.js/rx.js.async.d.ts
@@ -8,12 +8,83 @@
 
 declare module Rx {
     interface ObservableStatic {
-        start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
-        toAsync<T>(func: Function, scheduler?: IScheduler, context?: any): (...arguments: any[]) => Observable<T>;
-        fromCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: T[])=>T): () => Observable<T>;
-        fromNodeCallback<T>(func: (...arguments: any[]) => void, scheduler?: IScheduler, context?: any, selector?: (...arguments: any[])=>T): (...arguments: any[]) => Observable<T>;
-        fromEvent<T>(element: any, eventName: string, selector?: (...arguments: any[])=>T): Observable<T>;
-        fromEventPattern<T>(addHandler: (handler: any)=> void, removeHandler: (handler: any)=> void, selector?: (...arguments: any[])=>T): Observable<T>;
-        fromPromise<T>(promise: any): Observable<T>;
-    }
-}
\ No newline at end of file
+		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
+
+        toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+
+		fromCallback: {
+			// with single result callback without selector
+			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback with selector
+			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
+			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback without selector
+			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any function with selector
+			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
+			// with any function without selector
+			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
+		};
+
+		fromNodeCallback: {
+			// with single result callback without selector
+			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
+			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
+			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
+			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
+			// with any callback with selector
+			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
+			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
+			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any callback without selector
+			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
+			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
+			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any function with selector
+			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
+			// with any function without selector
+			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
+		};
+
+		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
+
+		fromPromise<T>(promise: { then(onFulfill: (value: T) => any, onReject?: (reason: any) => any): any; }): Observable<T>;
+		fromPromise<T>(promise: any): Observable<T>;
+	}
+}

From 6033488b47151cfa067ee8ad9afe0803bef7b420 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 21:38:05 +0400
Subject: [PATCH 10/22] updated rx.js.coincidence.d.ts: added overloads for
 window and buffer

---
 rx.js/rx.js.coincidence.d.ts | 38 ++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 21 deletions(-)

diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.js.coincidence.d.ts
index 3ec1a3a25..a87c2b4a3 100644
--- a/rx.js/rx.js.coincidence.d.ts
+++ b/rx.js/rx.js.coincidence.d.ts
@@ -3,34 +3,30 @@
 // Type definitions for RxJS-Coincidence package
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.coincidence.js
 
 declare module Rx {
 
 	interface Observable<T> {
-		join<T2, TDuration, T2Duration, TResult>(
-			right: Observable<T2>,
-			leftDurationSelector: (leftItem: T) => Observable<TDuration>,
-			rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
-			resultSelector: (leftItem: T, rightItem: T2) => TResult): Observable<TResult>;
+		join<TRight, TDurationLeft, TDurationRight, TResult>(
+			right: Observable<TRight>,
+			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
+			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
+			resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable<TResult>;
 
-		groupJoin<T2, TDuration, T2Duration, TResult>(
-			right: Observable<T2>,
-			leftDurationSelector: (leftItem: T) => Observable<TDuration>,
-			rightDurationSelector: (rightItem: T2) => Observable<T2Duration>,
-			resultSelector: (leftItem: T, rightItem: Observable<T2>) => TResult): Observable<TResult>;
+		groupJoin<TRight, TDurationLeft, TDurationRight, TResult>(
+			right: Observable<TRight>,
+			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
+			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
+			resultSelector: (leftItem: T, rightItem: Observable<TRight>) => TResult): Observable<TResult>;
 
+		window<TWindowOpening>(windowOpenings: Observable<TWindowOpening>): Observable<Observable<T>>;
+		window<TWindowClosing>(windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
+		window<TWindowOpening, TWindowClosing>(windowOpenings: Observable<TWindowOpening>, windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
 
-		// lack of documentation to complete the followings...
-
-		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
-			bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
-
-		window<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>,
-			bufferClosingSelector: (opening: TBufferOpening) => Observable<TBufferClosing>): Observable<T>;
+		buffer<TBufferOpening>(bufferOpenings: Observable<TBufferOpening>): Observable<T[]>;
+		buffer<TBufferClosing>(bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
+		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>, bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
 	}
 }

From 1e8d71d7e399e2847c2b045fba52f5d51367a196 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Sun, 15 Dec 2013 23:18:20 +0400
Subject: [PATCH 11/22] Created typings for rx.joinpatterns: Patterns, Plan,
 Observable.when

---
 rx.js/rx.js.joinpatterns.d.ts | 54 +++++++++++++++++++++++++++++------
 1 file changed, 45 insertions(+), 9 deletions(-)

diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.js.joinpatterns.d.ts
index fe6cf6bdd..1f1c40d7b 100644
--- a/rx.js/rx.js.joinpatterns.d.ts
+++ b/rx.js/rx.js.joinpatterns.d.ts
@@ -2,19 +2,55 @@
 
 // Type definitions for RxJS-Join package
 // Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.joinpatterns.js
 
 declare module Rx {
 
-	//interface Observable<T> {
-	//}
+	interface Pattern1<T1> {
+		and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
+		then<TR>(selector: (item1: T1) => TR): Plan<TR>;
+	}
+	interface Pattern2<T1, T2> {
+		and<T3>(other: Observable<T3>): Pattern3<T1, T2, T3>;
+		then<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
+	}
+	interface Pattern3<T1, T2, T3> {
+		and<T4>(other: Observable<T4>): Pattern4<T1, T2, T3, T4>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
+	}
+	interface Pattern4<T1, T2, T3, T4> {
+		and<T5>(other: Observable<T5>): Pattern5<T1, T2, T3, T4, T5>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan<TR>;
+	}
+	interface Pattern5<T1, T2, T3, T4, T5> {
+		and<T6>(other: Observable<T6>): Pattern6<T1, T2, T3, T4, T5, T6>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan<TR>;
+	}
+	interface Pattern6<T1, T2, T3, T4, T5, T6> {
+		and<T7>(other: Observable<T7>): Pattern7<T1, T2, T3, T4, T5, T6, T7>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan<TR>;
+	}
+	interface Pattern7<T1, T2, T3, T4, T5, T6, T7> {
+		and<T8>(other: Observable<T8>): Pattern8<T1, T2, T3, T4, T5, T6, T7, T8>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan<TR>;
+	}
+	interface Pattern8<T1, T2, T3, T4, T5, T6, T7, T8> {
+		and<T9>(other: Observable<T9>): Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan<TR>;
+	}
+	interface Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan<TR>;
+	}
 
+	interface Plan<T> { }
 
-	//interface Observable {
-	//}
+	interface Observable<T> {
+		and<T2>(other: Observable<T2>): Pattern2<T, T2>;
+		then<TR>(selector: (item1: T) => TR): Plan<TR>;
+	}
+
+	interface ObservableStatic {
+		when<TR>(plan: Plan<TR>): Observable<TR>;
+	}
 }

From 519423ea9a54ad9a8291c3d04ca13a53b4eb65a2 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 00:19:41 +0400
Subject: [PATCH 12/22] Added rx.testing.d.ts: TestScheduler, ReactiveTest,
 Subscription, MockObserver, Recorded

---
 rx.js/rx.js.time.d.ts |  5 +---
 rx.js/rx.testing.d.ts | 53 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 54 insertions(+), 4 deletions(-)
 create mode 100644 rx.js/rx.testing.d.ts

diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.js.time.d.ts
index 779a7b3c9..f0d7fb889 100644
--- a/rx.js/rx.js.time.d.ts
+++ b/rx.js/rx.js.time.d.ts
@@ -3,11 +3,8 @@
 // Type definitions for RxJS "Aggregates"
 // Project: http://rx.codeplex.com/
 // Definitions by: Carl de Billy <http://carl.debilly.net/>
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
-//
-// Dependencies:
-// -> rx.js
-// -> rx.time.js
 
 declare module Rx {
 
diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts
new file mode 100644
index 000000000..f2b6f4fff
--- /dev/null
+++ b/rx.js/rx.testing.d.ts
@@ -0,0 +1,53 @@
+///<reference path="rx.js.d.ts" />
+///<reference path="rx.js.virtualtime.d.ts" />
+
+// Type definitions for RxJS-Testing
+// Project: https://github.com/Reactive-Extensions/RxJS/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module Rx {
+	export class TestScheduler extends VirtualTimeScheduler<number, number> {
+		constructor();
+
+		createColdObservable<T>(...records: Recorded[]): Observable<T>;
+		createHotObservable<T>(...records: Recorded[]): Observable<T>;
+		createObserver<T>(): MockObserver<T>;
+
+		startWithTiming<T>(create: () => Observable<T>, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver<T>;
+		startWithDispose<T>(create: () => Observable<T>, disposedAt: number): MockObserver<T>;
+		startWithCreate<T>(create: () => Observable<T>): MockObserver<T>;
+	}
+
+	export class Recorded {
+		constructor(time: number, value: any, equalityComparer?: (x: any, y: any) => boolean);
+		equals(other: Recorded): boolean;
+		toString(): string;
+		time: number;
+		value: any;
+	}
+
+	export var ReactiveTest: {
+		created: number;
+		subscribed: number;
+		disposed: number;
+
+		onNext(ticks: number, value: any): Recorded;
+		onNext(ticks: number, predicate: (value: any) => boolean): Recorded;
+		onError(ticks: number, exception: any): Recorded;
+		onError(ticks: number, predicate: (exception: any) => boolean): Recorded;
+		onCompleted(ticks: number): Recorded;
+
+		subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription;
+	};
+
+	export class Subscription {
+		constructor(subscribeAt: number, unsubscribeAt?: number);
+		equals(other: Subscription): boolean;
+	}
+
+	export class MockObserver<T> extends Observer<T> {
+		constructor(scheduler: IScheduler);
+		messages: Recorded[];
+	}
+}

From 58a5b53bcde71c6e2aa40ee964af28488807b3cb Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 00:29:27 +0400
Subject: [PATCH 13/22] rx.js: removed *.tscparams files

---
 rx.js/rx.js.aggregates.d.ts.tscparams   | 1 -
 rx.js/rx.js.async.d.ts.tscparams        | 1 -
 rx.js/rx.js.binding.d.ts.tscparams      | 1 -
 rx.js/rx.js.coincidence.d.ts.tscparams  | 1 -
 rx.js/rx.js.d.ts.tscparams              | 1 -
 rx.js/rx.js.experimental.d.ts.tscparams | 1 -
 rx.js/rx.js.joinpatterns.d.ts.tscparams | 1 -
 rx.js/rx.js.jquery.d.ts.tscparams       | 1 -
 rx.js/rx.js.time.d.ts.tscparams         | 1 -
 rx.js/rx.js.virtualtime.d.ts.tscparams  | 1 -
 10 files changed, 10 deletions(-)
 delete mode 100644 rx.js/rx.js.aggregates.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.async.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.binding.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.coincidence.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.experimental.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.joinpatterns.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.jquery.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.time.d.ts.tscparams
 delete mode 100644 rx.js/rx.js.virtualtime.d.ts.tscparams

diff --git a/rx.js/rx.js.aggregates.d.ts.tscparams b/rx.js/rx.js.aggregates.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.aggregates.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.async.d.ts.tscparams b/rx.js/rx.js.async.d.ts.tscparams
deleted file mode 100644
index 3cc762b55..000000000
--- a/rx.js/rx.js.async.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
\ No newline at end of file
diff --git a/rx.js/rx.js.binding.d.ts.tscparams b/rx.js/rx.js.binding.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.binding.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.coincidence.d.ts.tscparams b/rx.js/rx.js.coincidence.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.coincidence.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.d.ts.tscparams b/rx.js/rx.js.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.experimental.d.ts.tscparams b/rx.js/rx.js.experimental.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.experimental.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.joinpatterns.d.ts.tscparams b/rx.js/rx.js.joinpatterns.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.joinpatterns.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.jquery.d.ts.tscparams b/rx.js/rx.js.jquery.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.jquery.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.time.d.ts.tscparams b/rx.js/rx.js.time.d.ts.tscparams
deleted file mode 100644
index e16c76dff..000000000
--- a/rx.js/rx.js.time.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
diff --git a/rx.js/rx.js.virtualtime.d.ts.tscparams b/rx.js/rx.js.virtualtime.d.ts.tscparams
deleted file mode 100644
index 3cc762b55..000000000
--- a/rx.js/rx.js.virtualtime.d.ts.tscparams
+++ /dev/null
@@ -1 +0,0 @@
-""
\ No newline at end of file

From 249fd303b303cfae029a433d5711bcc2cb65edf7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 09:58:41 +0400
Subject: [PATCH 14/22] Renamed rx.js.*.d.ts files into rx.*.d.ts; fixed
 references

---
 rx.js/{rx.js.aggregates.d.ts => rx.aggregates.d.ts}     | 0
 rx.js/{rx.js.async.d.ts => rx.async.d.ts}               | 0
 rx.js/{rx.js.binding.d.ts => rx.binding.d.ts}           | 0
 rx.js/{rx.js.coincidence.d.ts => rx.coincidence.d.ts}   | 0
 rx.js/{rx.js.d.ts => rx.d.ts}                           | 0
 rx.js/{rx.js.experimental.d.ts => rx.experimental.d.ts} | 0
 rx.js/{rx.js.joinpatterns.d.ts => rx.joinpatterns.d.ts} | 0
 rx.js/{rx.js.jquery.d.ts => rx.jquery.d.ts}             | 0
 rx.js/rx.testing.d.ts                                   | 4 ++--
 rx.js/{rx.js.time.d.ts => rx.time.d.ts}                 | 0
 rx.js/{rx.js.virtualtime.d.ts => rx.virtualtime.d.ts}   | 0
 11 files changed, 2 insertions(+), 2 deletions(-)
 rename rx.js/{rx.js.aggregates.d.ts => rx.aggregates.d.ts} (100%)
 rename rx.js/{rx.js.async.d.ts => rx.async.d.ts} (100%)
 rename rx.js/{rx.js.binding.d.ts => rx.binding.d.ts} (100%)
 rename rx.js/{rx.js.coincidence.d.ts => rx.coincidence.d.ts} (100%)
 rename rx.js/{rx.js.d.ts => rx.d.ts} (100%)
 rename rx.js/{rx.js.experimental.d.ts => rx.experimental.d.ts} (100%)
 rename rx.js/{rx.js.joinpatterns.d.ts => rx.joinpatterns.d.ts} (100%)
 rename rx.js/{rx.js.jquery.d.ts => rx.jquery.d.ts} (100%)
 rename rx.js/{rx.js.time.d.ts => rx.time.d.ts} (100%)
 rename rx.js/{rx.js.virtualtime.d.ts => rx.virtualtime.d.ts} (100%)

diff --git a/rx.js/rx.js.aggregates.d.ts b/rx.js/rx.aggregates.d.ts
similarity index 100%
rename from rx.js/rx.js.aggregates.d.ts
rename to rx.js/rx.aggregates.d.ts
diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.async.d.ts
similarity index 100%
rename from rx.js/rx.js.async.d.ts
rename to rx.js/rx.async.d.ts
diff --git a/rx.js/rx.js.binding.d.ts b/rx.js/rx.binding.d.ts
similarity index 100%
rename from rx.js/rx.js.binding.d.ts
rename to rx.js/rx.binding.d.ts
diff --git a/rx.js/rx.js.coincidence.d.ts b/rx.js/rx.coincidence.d.ts
similarity index 100%
rename from rx.js/rx.js.coincidence.d.ts
rename to rx.js/rx.coincidence.d.ts
diff --git a/rx.js/rx.js.d.ts b/rx.js/rx.d.ts
similarity index 100%
rename from rx.js/rx.js.d.ts
rename to rx.js/rx.d.ts
diff --git a/rx.js/rx.js.experimental.d.ts b/rx.js/rx.experimental.d.ts
similarity index 100%
rename from rx.js/rx.js.experimental.d.ts
rename to rx.js/rx.experimental.d.ts
diff --git a/rx.js/rx.js.joinpatterns.d.ts b/rx.js/rx.joinpatterns.d.ts
similarity index 100%
rename from rx.js/rx.js.joinpatterns.d.ts
rename to rx.js/rx.joinpatterns.d.ts
diff --git a/rx.js/rx.js.jquery.d.ts b/rx.js/rx.jquery.d.ts
similarity index 100%
rename from rx.js/rx.js.jquery.d.ts
rename to rx.js/rx.jquery.d.ts
diff --git a/rx.js/rx.testing.d.ts b/rx.js/rx.testing.d.ts
index f2b6f4fff..8a2dc35e5 100644
--- a/rx.js/rx.testing.d.ts
+++ b/rx.js/rx.testing.d.ts
@@ -1,5 +1,5 @@
-///<reference path="rx.js.d.ts" />
-///<reference path="rx.js.virtualtime.d.ts" />
+///<reference path="rx.d.ts" />
+///<reference path="rx.virtualtime.d.ts" />
 
 // Type definitions for RxJS-Testing
 // Project: https://github.com/Reactive-Extensions/RxJS/
diff --git a/rx.js/rx.js.time.d.ts b/rx.js/rx.time.d.ts
similarity index 100%
rename from rx.js/rx.js.time.d.ts
rename to rx.js/rx.time.d.ts
diff --git a/rx.js/rx.js.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
similarity index 100%
rename from rx.js/rx.js.virtualtime.d.ts
rename to rx.js/rx.virtualtime.d.ts

From 6ac83ca52e4c6e0c04fccb1e5188a28d03c27f8e Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 11:24:24 +0400
Subject: [PATCH 15/22] Updated rx.jquery.d.ts

---
 rx.js/rx.jquery.d.ts | 113 ++++++++++++++-----------------------------
 1 file changed, 35 insertions(+), 78 deletions(-)

diff --git a/rx.js/rx.jquery.d.ts b/rx.js/rx.jquery.d.ts
index 75db935a9..fd9311ee4 100644
--- a/rx.js/rx.jquery.d.ts
+++ b/rx.js/rx.jquery.d.ts
@@ -1,58 +1,10 @@
-///<reference path="../jquery/jquery.d.ts"/>
-///<reference path="rx.js.d.ts"/>
-
-// Those are the definitions for bridging Rx with jQuery.
-//
-// Using the https://github.com/Reactive-Extensions/rxjs-jquery project
-//
-// Dependencies:
-// -> rx.js
-// -> rx.jquery.js
-// -> jquery.js
-
-declare module JQueryResults {
-
-	export interface eventBase{
-		bubbles: boolean;
-		cancelable: boolean;
-		type: string;
-		preventDefault(): void;
-		isDefaultPrevented(): boolean;
-		stopPropagation(): void;
-		isPropagationStopped(): boolean;
-		data: any;
-		originalEvent: any;
-		eventPhase: number;
-	}
-
-	export interface keyEvent extends eventBase {
-		key: number;
-		keyCode: number;
-		altKey: boolean;
-		ctrlKey: boolean;
-		shiftKey: boolean;
-		char: string;
-		metaKey: boolean;
-	}
-
-	export interface uiEvent extends eventBase{
-		target: any;
-		currentTarget: any;
-	}
-
-	export interface mouseEvent extends keyEvent{
-		clientX: number;
-		clientY: number;
-		screenX: number;
-		screenY: number;
-		offsetX: number;
-		offsetY: number;
-		pageX: number;
-		pageY: number;
-		which: number;
-	}
-}
+// Type definitions for bridging RxJS with jQuery.
+// Project: https://github.com/Reactive-Extensions/RxJS-jQuery/
+// Revision by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+///<reference path="../jquery/jquery.d.ts"/>
+///<reference path="rx.d.ts"/>
 
 interface JQueryStatic {
 	ajaxAsObservable<T>(settings: JQueryAjaxSettings): Rx.Observable<T>;
@@ -63,29 +15,34 @@ interface JQueryStatic {
 }
 
 interface JQuery {
-	changeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	clickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	dblclickAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	focusAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	focusinAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	focusoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	keydownAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
-	keyupAsObservable(eventData?: any): Rx.Observable<JQueryResults.keyEvent>;
-	loadAsObservable(eventData?: any): Rx.Observable<JQueryResults.uiEvent>;
-	mousedownAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mouseenterAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mouseleaveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mousemoveAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mouseoutAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mouseoverAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	mouseupAsObservable(eventData?: any): Rx.Observable<JQueryResults.mouseEvent>;
-	resizeAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	scrollAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	selectAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	submitAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	unloadAsObservable(eventData?: any): Rx.Observable<JQueryResults.eventBase>;
-	hideAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
-	showAsObservable(duration: number): Rx.Observable<JQueryResults.eventBase>;
+	onAsObservable<T extends BaseJQueryEventObject>(events: string, selector?: string, eventData?: any): Rx.Observable<T>;
+	bindAsObservable<T extends BaseJQueryEventObject>(eventType: string, eventData?: any): Rx.Observable<T>;
+	delegateAsObservable<T extends BaseJQueryEventObject>(selector: string, eventType: string, eventData?: any): Rx.Observable<T>;
+	//liveAsObservable<T extends BaseJQueryEventObject>(eventType: string, eventData?: any): Rx.Observable<T>;	// removed in jquery 1.9
+
+	changeAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
+	clickAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	dblclickAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	focusAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
+	focusinAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
+	focusoutAsObservable(eventData?: any): Rx.Observable<JQueryInputEventObject>;
+	keydownAsObservable(eventData?: any): Rx.Observable<JQueryKeyEventObject>;
+	keyupAsObservable(eventData?: any): Rx.Observable<JQueryKeyEventObject>;
+	loadAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	mousedownAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mouseenterAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mouseleaveAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mousemoveAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mouseoutAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mouseoverAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	mouseupAsObservable(eventData?: any): Rx.Observable<JQueryMouseEventObject>;
+	resizeAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	scrollAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	selectAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	submitAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	unloadAsObservable(eventData?: any): Rx.Observable<BaseJQueryEventObject>;
+	hideAsObservable(duration: number): Rx.Observable<BaseJQueryEventObject>;
+	showAsObservable(duration: number): Rx.Observable<BaseJQueryEventObject>;
 	readyAsObservable(): Rx.Observable<any>;
 	animateAsObservable(properties: any, duration: number, easing?: string): Rx.Observable<any>;
 	fadeInAsObservable(duration: number, easing?: string): Rx.Observable<any>;
@@ -96,4 +53,4 @@ interface JQuery {
 	slideUpAsObservable(duration: number): Rx.Observable<any>;
 	slideToggleAsObservable(duration: number): Rx.Observable<any>;
 	toggleAsObservable(duration: number): Rx.Observable<any>;
-}
\ No newline at end of file
+}

From a2186d91623fd75ed797bf5112e7eb5bf8de5d80 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 12:57:25 +0400
Subject: [PATCH 16/22] Fixed reference in rx-tests.ts

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

diff --git a/rx.js/rx-tests.ts b/rx.js/rx-tests.ts
index d95988ce6..aa94bcffc 100644
--- a/rx.js/rx-tests.ts
+++ b/rx.js/rx-tests.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts"/>
+///<reference path="rx.d.ts"/>
 
 // Disposable
 var d: Rx.IDisposable = new Rx.Disposable(() => { });

From f61f1bbd53ab35635be36526c197da51100360eb Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 14:02:11 +0400
Subject: [PATCH 17/22] Removed rx-tests.ts via TS bug
 https://typescript.codeplex.com/workitem/2011

---
 rx.js/rx-tests.ts | 281 ----------------------------------------------
 1 file changed, 281 deletions(-)
 delete mode 100644 rx.js/rx-tests.ts

diff --git a/rx.js/rx-tests.ts b/rx.js/rx-tests.ts
deleted file mode 100644
index aa94bcffc..000000000
--- a/rx.js/rx-tests.ts
+++ /dev/null
@@ -1,281 +0,0 @@
-///<reference path="rx.d.ts"/>
-
-// Disposable
-var d: Rx.IDisposable = new Rx.Disposable(() => { });
-d = Rx.Disposable.create(() => { });
-d = Rx.Disposable.empty;
-d.dispose();
-
-// CompositeDisposable
-var cd = new Rx.CompositeDisposable(d, d, d);
-d = cd;
-cd = new Rx.CompositeDisposable([d, d]);
-cd.add(d);
-cd.clear();
-var b: boolean = cd.contains(d);
-var da: Rx.IDisposable[] = cd.toArray();
-cd.remove(d);
-
-// SingleAssignmentDisposable
-var sad = new Rx.SingleAssignmentDisposable();
-d = sad;
-sad.setDisposable(d);
-d = sad.getDisposable();
-b = sad.isDisposed;
-
-// SerialDisposable
-var sd = new Rx.SerialDisposable();
-d = sd;
-sd.setDisposable(d);
-d = sd.getDisposable();
-b = sd.isDisposed;
-
-// RefCountDisposable
-var rcd = new Rx.RefCountDisposable(d);
-d = rcd;
-d = rcd.getDisposable();
-b = rcd.isDisposed;
-
-// IScheduler
-var s: Rx.IScheduler;
-var n: number = s.now();
-s = s.catch(ex => true);
-s = s.catchException(ex => true);
-d = s.schedule(() => { });
-d = s.scheduleWithState(1,
-	(sh, s) => sh.scheduleWithAbsoluteAndState(s + 1, 100,
-		(sh, s) => sh.scheduleWithRelativeAndState(s + 1, 200,
-			(sh, s) => sh.scheduleRecursiveWithState(s + 1,
-				(s, self) => self(s + 1)))));
-d = s.scheduleWithAbsolute(100, () => { });
-d = s.scheduleWithRelative(100, () => { });
-d = s.scheduleRecursive(self => self());
-d = s.scheduleRecursiveWithAbsolute(100, self => self(200));
-d = s.scheduleRecursiveWithRelative(100, self => self(200));
-d = s.schedulePeriodic(100, () => { });
-d = s.schedulePeriodicWithState('a', 100, s => s + 'b');
-
-// ICurrentThreadScheduler
-Rx.Scheduler.currentThread.scheduleRequired();
-Rx.Scheduler.currentThread.ensureTrampoline(() => Rx.Disposable.empty);
-
-// Observer
-var o: Rx.Observer<number> = Rx.Observer.create<number>();
-o = Rx.Observer.create<number>(i => { });
-o = Rx.Observer.create<number>(i => { }, err => { });
-o = Rx.Observer.create<number>(i => { }, err => { }, () => { });
-o = Rx.Observer.fromNotifier<number>(n => { });
-
-o.onNext(10);
-o.onError(new Error());
-o.onCompleted();
-
-// Observable static methods tests
-
-var ns: Rx.Observable<number> = Rx.Observable.create<number>(observer => { });
-var ss: Rx.Observable<string> = Rx.Observable.create<string>(observer => (() => { }));
-var bs: Rx.Observable<boolean> = Rx.Observable.createWithDisposable<boolean>(observer => Rx.Disposable.empty);
-
-ns = Rx.Observable.defer(() => ns);
-
-ss = Rx.Observable.empty<string>();
-bs = Rx.Observable.empty<boolean>(Rx.Scheduler.currentThread);
-
-ns = Rx.Observable.fromArray([0, 3, -7, 18]);
-ss = Rx.Observable.fromArray(['a', 'ab', 'abc'], Rx.Scheduler.timeout);
-
-ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i);
-ns = Rx.Observable.generate(0, i => i < 100, i => i + 1, i => i * i, Rx.Scheduler.timeout);
-
-bs = Rx.Observable.never<boolean>();
-
-ns = Rx.Observable.range(0, 100);
-ns = Rx.Observable.range(0, 100, Rx.Scheduler.timeout);
-
-ns = Rx.Observable.repeat(0, 100);
-ns = Rx.Observable.repeat(0, 100, Rx.Scheduler.timeout);
-
-ss = Rx.Observable.return('a');
-ss = Rx.Observable.return('a', Rx.Scheduler.timeout);
-ss = Rx.Observable.returnValue('a');
-ss = Rx.Observable.returnValue('a', Rx.Scheduler.timeout);
-
-bs = Rx.Observable.throw<boolean>(new Error("error"));
-bs = Rx.Observable.throw<boolean>(new Error("error"), Rx.Scheduler.timeout);
-bs = Rx.Observable.throwException<boolean>(new Error("error"));
-bs = Rx.Observable.throwException<boolean>(new Error("error"), Rx.Scheduler.timeout);
-
-bs = Rx.Observable.using(() => d, d => Rx.Observable.return(true));
-
-ss = Rx.Observable.amb(ss, ss);
-//ss = Rx.Observable.amb([ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-
-ss = Rx.Observable.catch(ss, ss, ss);
-ss = Rx.Observable.catchException(ss, ss, ss);
-//ss = Rx.Observable.catch([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-//ss = Rx.Observable.catchException([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-
-ss = Rx.Observable.concat(ss, ss, ss);
-//ss = Rx.Observable.concat([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-
-ss = Rx.Observable.merge(ss, ss, ss);
-//ss = Rx.Observable.merge([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-ss = Rx.Observable.merge(s, ss, ss, ss);
-//ss = Rx.Observable.merge(s, [ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-
-ss = Rx.Observable.onErrorResumeNext(ss, ss, ss);
-//ss = Rx.Observable.onErrorResumeNext([ss, ss, ss]);	// TypeScript bug https://typescript.codeplex.com/workitem/2011
-
-ns = Rx.Observable.zip(ss, [ss, ss, ss], (s, ss2) => { ss = ss2; return s.charCodeAt(0); });
-ns = Rx.Observable.zip(ss, bs, (s, b) => s.length + (b ? 1 : 0));
-ns = Rx.Observable.zip(ss, bs, ns, (s, b, n) => s.length + (b ? 1 : 0) + n);
-ns = Rx.Observable.zip(ss, bs, ns, ns, (s, b, n, n2) => s.length + (b ? 1 : 0) + n + n2);
-ns = Rx.Observable.zip(ss, bs, ns, ns, ss, (s, b, n, n2, s2) => s.length + (b ? 1 : 0) + n + n2 + s2.charCodeAt(0));
-
-var sas: Rx.Observable<string[]> = Rx.Observable.zipArray(ss, ss);
-
-
-// Observable instance methods
-
-d = ns.subscribe(o);
-d = ns.subscribe(n => n + 1, err => { }, () => { });
-d = ns.subscribe(n => n + 1, err => { });
-d = ns.subscribe();
-
-sas = ss.toArray();
-
-ss.observeOn(s);
-ns.subscribeOn(s);
-
-ss = ss.amb(ss);
-
-ss = ss.catch(err => ss);
-ss = ss.catchException(err => ss);
-ss = ss.catch(ss);
-ss = ss.catchException(ss);
-
-ns = ss.combineLatest([ns, ns, ns], (s, ...ns) => s.charCodeAt(0) + ns[0]);
-ns = ss.combineLatest(ns, (s, n) => s.charCodeAt(0) + n);
-ns = ss.combineLatest(ns, ns, (s, n, n2) => s.charCodeAt(0) + n + n2);
-ns = ss.combineLatest(ns, ns, bs, (s, n, n2, b) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0));
-ns = ss.combineLatest(ns, ns, bs, ss, (s, n, n2, b, s2) => s.charCodeAt(0) + n + n2 + (b ? 1 : 0) + s2.charCodeAt(0));
-
-ss = ss.concat(ss, ss);
-ss = ss.concat([ss, ss]);
-
-var sss: Rx.Observable<Rx.Observable<string>>;
-ss = sss.concatAll();
-ss = sss.concatObservable();
-
-ss = ss.merge(2);
-ss = ss.merge(ss);
-
-ss = sss.mergeAll();
-ss = sss.mergeObservable();
-
-ss = ss.onErrorResumeNext(ss);
-
-ss = ss.skipUntil(ns);
-
-ss = ss.takeUntil(ns);
-
-ss = sss.switchLatest();
-
-ns = ss.zip([ns, ns], (s, ns2) => { ns = ns2; return s.charCodeAt(0); });
-
-ns = ss.zip(ns, (s, n) => s.charCodeAt(0) + n);
-ns = ss.zip(ns, bs, (s, n, b) => s.charCodeAt(0) + n + (b?1:0));
-ns = ss.zip(ns, bs, ss, (s, n, b, s2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0));
-ns = ss.zip(ns, bs, ss, ns, (s, n, b, s2, n2) => s.charCodeAt(0) + n + (b?1:0) + s2.charCodeAt(0) + n2);
-
-ss = ss.asObservable();
-
-sas = ss.bufferWithCount(2);
-sas = ss.bufferWithCount(2, 1);
-
-var notifications: Rx.Observable<Rx.Notification<number>>;
-
-ns = notifications.dematerialize<number>();
-
-ns = ns.distinctUntilChanged();
-ns = ns.distinctUntilChanged(n => (n + 1).toString());
-ns = ns.distinctUntilChanged(n => (n + 1).toString(), (s1, s2) => s1.charCodeAt(0) === s2.charCodeAt(0));
-ns = ns.distinctUntilChanged(undefined, (n1, n2) => (n1 + 1) === (n2 + 1));
-
-ns = ns.do(o);
-ns = ns.doAction(o);
-ns = ns.do(n => n + 1, err => { }, () => { });
-ns = ns.doAction(n => n + 1, err => { }, () => { });
-ns = ns.do(n => n + 1, err => { });
-ns = ns.doAction(n => n + 1, err => { });
-ns = ns.do();
-ns = ns.doAction();
-
-ns = ns.finally(() => { });
-ns = ns.finallyAction(() => { });
-
-ss = ss.ignoreElements();
-
-notifications = ns.materialize();
-
-ss = ss.repeat();
-ss = ss.repeat(10);
-
-ss = ss.retry();
-ss = ss.retry(10);
-
-ns = ss.scan(0, (sum, s) => sum + s.charCodeAt(0));
-ns = ns.scan((sum, n) => sum + n);
-
-ns = ns.skipLast(10);
-
-ns = ns.startWith(10, 20);
-ns = ns.startWith(s, 10, 20);
-
-ns = ns.takeLast(2);
-ns = ns.takeLast(2, s);
-
-sas = ss.takeLastBuffer(5);
-
-sss = ss.windowWithCount(2);
-sss = ss.windowWithCount(2, 3);
-
-ns = ns.defaultIfEmpty();
-ns = ns.defaultIfEmpty(0);
-
-ns = ns.distinct(n => (n + 1), n => (n + 1).toString());
-ns = ns.distinct(undefined, n => (n + 1).toString());
-ns = ns.distinct(n => (n + 1).toString());
-ns = ns.distinct();
-
-var gnss: Observable<GroupedObservable<number, string>>;
-var group: GroupedObservable<number, string>;
-ss = group;
-n = group.key;
-
-gnss = ss.groupBy(s => s.charCodeAt(0));
-gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!");
-gnss = ss.groupBy(s => s.charCodeAt(0), s => s + "!", k => (k + 1).toString());
-gnss = ss.groupBy(s => s.charCodeAt(0), undefined, k => (k + 1).toString());
-
-gnss = ss.groupByUntil(s => s.charCodeAt(0), s => s + "!", g => ns, k => (k + 1).toString());
-gnss = ss.groupByUntil(s => s.charCodeAt(0), undefined, g => ns, k => (k + 1).toString());
-
-ns = ss.select(s => s.charCodeAt(0), ns);
-ns = ss.map(s => s.charCodeAt(0), ns);
-ns = ss.select(s => s.charCodeAt(0));
-ns = ss.map(s => s.charCodeAt(0));
-ns = ss.select((s, index) => s.charCodeAt(0) + index);
-ns = ss.map((s, index) => s.charCodeAt(0) + index);
-ns = ss.select((s, index) => s.charCodeAt(0) + index, ns);
-ns = ss.map((s, index) => s.charCodeAt(0) + index, ns);
-ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
-ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; });
-ns = ss.select((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
-ns = ss.map((s, index, source) => { ss = source; return; s.charCodeAt(0) + index; }, ns);
-
-ss = ss.selectMany(s => ns, (s, n) => s + n.toString());
-ns = ss.selectMany(s => ns);
-ns = ss.selectMany(ns);
-
-ns = ns.skip(10);

From ba81c3067531ed74bc24d07facdf90e366f97364 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 15:28:25 +0400
Subject: [PATCH 18/22] rx.js: fixed references rx.js.* -> rx.*

---
 rx.js/rx.aggregates.d.ts   | 2 +-
 rx.js/rx.async.d.ts        | 2 +-
 rx.js/rx.binding.d.ts      | 2 +-
 rx.js/rx.coincidence.d.ts  | 2 +-
 rx.js/rx.experimental.d.ts | 2 +-
 rx.js/rx.joinpatterns.d.ts | 2 +-
 rx.js/rx.time.d.ts         | 2 +-
 rx.js/rx.virtualtime.d.ts  | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/rx.js/rx.aggregates.d.ts b/rx.js/rx.aggregates.d.ts
index fcc368461..24ed13f1d 100644
--- a/rx.js/rx.aggregates.d.ts
+++ b/rx.js/rx.aggregates.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-Aggregates package
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.async.d.ts b/rx.js/rx.async.d.ts
index 8adfeae4c..5ee13b89a 100644
--- a/rx.js/rx.async.d.ts
+++ b/rx.js/rx.async.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-Async package 2.2
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.binding.d.ts b/rx.js/rx.binding.d.ts
index 0a749cc8e..22624cc23 100644
--- a/rx.js/rx.binding.d.ts
+++ b/rx.js/rx.binding.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-Binding package
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.coincidence.d.ts b/rx.js/rx.coincidence.d.ts
index a87c2b4a3..2afa5cfe9 100644
--- a/rx.js/rx.coincidence.d.ts
+++ b/rx.js/rx.coincidence.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-Coincidence package
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.experimental.d.ts b/rx.js/rx.experimental.d.ts
index a1a7fbea3..db23df3fd 100644
--- a/rx.js/rx.experimental.d.ts
+++ b/rx.js/rx.experimental.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="rx.js.d.ts"/>
+/// <reference path="rx.d.ts"/>
 
 declare module Rx {
 
diff --git a/rx.js/rx.joinpatterns.d.ts b/rx.js/rx.joinpatterns.d.ts
index 1f1c40d7b..d23264f8e 100644
--- a/rx.js/rx.joinpatterns.d.ts
+++ b/rx.js/rx.joinpatterns.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-Join package
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.time.d.ts b/rx.js/rx.time.d.ts
index f0d7fb889..2d5f1d14f 100644
--- a/rx.js/rx.time.d.ts
+++ b/rx.js/rx.time.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS "Aggregates"
 // Project: http://rx.codeplex.com/
diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
index fe5d21689..9167f0fab 100644
--- a/rx.js/rx.virtualtime.d.ts
+++ b/rx.js/rx.virtualtime.d.ts
@@ -1,4 +1,4 @@
-///<reference path="rx.js.d.ts" />
+///<reference path="rx.d.ts" />
 
 // Type definitions for RxJS-VirtualTime package 2.2
 // Project: http://rx.codeplex.com/

From 9f7339ed64cb516fd51ef624ed00855b3a547ba3 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 15:33:29 +0400
Subject: [PATCH 19/22] rx.js: updated README.md contributors for rx.js

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7e305efe3..800f6abf9 100755
--- a/README.md
+++ b/README.md
@@ -202,7 +202,7 @@ List of Definitions
 * [Riot.js](https://github.com/moot/riotjs) (by [vvakame](https://github.com/vvakame))
 * [Restify](https://github.com/mcavage/node-restify) (by [Bret Little](https://github.com/blittle))
 * [Royalslider](http://dimsemenov.com/plugins/royal-slider/) (by [Christiaan Rakowski](https://github.com/csrakowski))
-* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino))
+* [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino), [Igor Oleinikov](https://github.com/Igorbek), [Carl de Billy](http://carl.debilly.net/), [zoetrope](https://github.com/zoetrope))
 * [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall))
 * [Restangular](https://github.com/mgonto/restangular/) (by [Boris Yankov](https://github.com/borisyankov))
 * [require.js](http://requirejs.org/) (by [Josh Baldwin](https://github.com/jbaldwin/))

From 9381a60dcbca4d777141fd2106ea8002a9b1d251 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 15:57:03 +0400
Subject: [PATCH 20/22] knockout.rx: fixed reference to rx.js

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

diff --git a/knockout.rx/knockout.rx.d.ts b/knockout.rx/knockout.rx.d.ts
index 4f44153d8..e9c85a7f8 100644
--- a/knockout.rx/knockout.rx.d.ts
+++ b/knockout.rx/knockout.rx.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 
 /// <reference path="../knockout/knockout.d.ts"/>
-/// <reference path="../rx.js/rx.js.d.ts"/>
+/// <reference path="../rx.js/rx.d.ts"/>
 
 interface KnockoutSubscribableFunctions<T> {
 	toObservable(event?: string): Rx.IObservable<T>;

From a0bce74b1ca81ec84f994a90c902a5b925d7215f Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 16:02:13 +0400
Subject: [PATCH 21/22] rx.js: fixed --noImplicitAny errors

---
 rx.js/rx.d.ts             | 4 ++--
 rx.js/rx.virtualtime.d.ts | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index b2ad79a48..a9125dd13 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -30,7 +30,7 @@ declare module Rx {
 		}
 
 		export class ScheduledItem<TTime> {
-			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
+			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => IDisposable, dueTime: TTime, comparer?: (x: TTime, y: TTime) => number);
 
 			scheduler: IScheduler;
 			state: TTime;
@@ -182,7 +182,7 @@ declare module Rx {
 		exception: any;
 
 		static createOnNext<T>(value: T): Notification<T>;
-		static createOnError<T>(exception): Notification<T>;
+		static createOnError<T>(exception: any): Notification<T>;
 		static createOnCompleted<T>(): Notification<T>;
 	}
 
diff --git a/rx.js/rx.virtualtime.d.ts b/rx.js/rx.virtualtime.d.ts
index 9167f0fab..293343fda 100644
--- a/rx.js/rx.virtualtime.d.ts
+++ b/rx.js/rx.virtualtime.d.ts
@@ -11,13 +11,13 @@ declare module Rx {
 	export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
 		constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
 
-		advanceBy(time: TRelative);
-		advanceTo(time: TAbsolute);
-		scheduleAbsolute(dueTime: TAbsolute, action: () => void);
+		advanceBy(time: TRelative): void;
+		advanceTo(time: TAbsolute): void;
+		scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable;
 		scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
 		scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
 		scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		sleep(time: TRelative);
+		sleep(time: TRelative): void;
 		start(): IDisposable;
 		stop(): void;
 

From 7fcae51ab119627267e291464baeec2a2e1caa77 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 16 Dec 2013 23:02:19 +0400
Subject: [PATCH 22/22] rx.js: added Observable.zipArray overload (by
 https://github.com/Reactive-Extensions/RxJS/issues/79)

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

diff --git a/rx.js/rx.d.ts b/rx.js/rx.d.ts
index a9125dd13..f055452e3 100644
--- a/rx.js/rx.d.ts
+++ b/rx.js/rx.d.ts
@@ -321,7 +321,7 @@ declare module Rx {
 		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, 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[]>;
+		zipArray<T>(sources: Observable<T>[]): Observable<T[]>;
 	}
 
 	export var Observable: ObservableStatic;