diff --git a/rx.js/rx.js.async.d.ts b/rx.js/rx.js.async.d.ts
index fa336ac7e4..49e1ec59b5 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 0921f30c58..0a749cc8e8 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 7aa0ae65aa..3ec1a3a25f 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 84ea913322..b2ad79a48f 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 1a1c38f54a..a1a7fbea36 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 04b39acecc..fe5d216892 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);
+	}
+}