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] 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