diff --git a/rx/rx-lite.d.ts b/rx/rx-lite.d.ts
index 4b5acb81d..fc7583353 100644
--- a/rx/rx-lite.d.ts
+++ b/rx/rx-lite.d.ts
@@ -60,6 +60,7 @@ declare module Rx {
 		function isPromise(p: any): boolean;
 		function asArray<T>(...args: T[]): T[];
 		function not(value: any): boolean;
+		function isFunction(value: any): boolean;
 	}
 
 	export interface IDisposable {
@@ -76,8 +77,6 @@ declare module Rx {
 		dispose(): void;
 		add(item: IDisposable): void;
 		remove(item: IDisposable): boolean;
-		clear(): void;
-		contains(item: IDisposable): boolean;
 		toArray(): IDisposable[];
 	}
 
@@ -102,15 +101,9 @@ declare module Rx {
 		setDisposable(value: IDisposable): void ;
 	}
 
-	// Multiple assignment disposable
-	export class SerialDisposable implements IDisposable {
+	// SerialDisposable it's an alias of SingleAssignmentDisposable
+	export class SerialDisposable extends SingleAssignmentDisposable {
 		constructor();
-
-		isDisposed: boolean;
-
-		dispose(): void;
-		getDisposable(): IDisposable;
-		setDisposable(value: IDisposable): void;
 	}
 
 	export class RefCountDisposable implements IDisposable {
@@ -188,7 +181,7 @@ declare module Rx {
 
 	interface ObserverStatic {
 		create<T>(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observer<T>;
-		fromNotifier<T>(handler: (notification: Notification<T>) => void): Observer<T>;
+		fromNotifier<T>(handler: (notification: Notification<T>, thisArg?: any) => void): Observer<T>;
 	}
 
 	export var Observer: ObserverStatic;
@@ -196,6 +189,10 @@ declare module Rx {
 	export interface IObservable<T> {
 		subscribe(observer: Observer<T>): IDisposable;
 		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
+
+		subscribeOnNext(onNext: (value: T) => void, thisArg?: any): IDisposable;
+		subscribeOnError(onError: (exception: any) => void, thisArg?: any): IDisposable;
+		subscribeOnCompleted(onCompleted: () => void, thisArg?: any): IDisposable;
 	}
 
 	export interface Observable<T> extends IObservable<T> {
@@ -271,8 +268,18 @@ declare module Rx {
 		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
+		tap(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
+		tap(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
+		
+		doOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
+		doOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
+		doOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
+		tapOnNext(onNext: (value: T) => void, thisArg?: any): Observable<T>;
+		tapOnError(onError: (exception: any) => void, thisArg?: any): Observable<T>;
+		tapOnCompleted(onCompleted: () => void, thisArg?: any): Observable<T>;
+
 		finally(action: () => void): Observable<T>;
 		finallyAction(action: () => void): Observable<T>;	// alias for finally
 		ignoreElements(): Observable<T>;
@@ -284,11 +291,12 @@ declare module Rx {
 		skipLast(count: number): Observable<T>;
 		startWith(...values: T[]): Observable<T>;
 		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
-		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
+		takeLast(count: number): Observable<T>;
 		takeLastBuffer(count: number): Observable<T[]>;
 
 		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
+		pluck<TResult>(prop: string): Observable<TResult>;
 		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
 		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
 		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
@@ -316,7 +324,7 @@ declare module Rx {
 		* @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences 
 		*  and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
 		*/
-		selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
+		selectSwitch<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;
 		/**
 		*  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then 
 		*  transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
@@ -325,7 +333,7 @@ declare module Rx {
 		* @returns An observable sequence whose elements are the result of invoking the transform function on each element of source producing an Observable of Observable sequences 
 		*  and that at any point in time produces the elements of the most recent inner observable sequence that has been received.
 		*/
-		flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for selectSwitch
+		flatMapLatest<TResult>(selector: (value: T, index: number, source: Observable<T>) => Observable<TResult>, thisArg?: any): Observable<TResult>;	// alias for selectSwitch
 		/**
 		*  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then 
 		*  transforms an observable sequence of observable sequences into an observable sequence producing values only from the most recent observable sequence.
@@ -501,15 +509,21 @@ declare module Rx {
 		throw<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
+		throwError<T>(error: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
+		throwError<T>(error: any, scheduler?: IScheduler): Observable<T>;	// alias for throw
 
 		catch<T>(sources: Observable<T>[]): Observable<T>;
 		catch<T>(sources: IPromise<T>[]): Observable<T>;
 		catchException<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
 		catchException<T>(sources: IPromise<T>[]): Observable<T>;	// alias for catch
+		catchError<T>(sources: Observable<T>[]): Observable<T>;	// alias for catch
+		catchError<T>(sources: IPromise<T>[]): Observable<T>;	// alias for catch
 		catch<T>(...sources: Observable<T>[]): Observable<T>;
 		catch<T>(...sources: IPromise<T>[]): Observable<T>;
 		catchException<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
 		catchException<T>(...sources: IPromise<T>[]): Observable<T>;	// alias for catch
+		catchError<T>(...sources: Observable<T>[]): Observable<T>;	// alias for catch
+		catchError<T>(...sources: IPromise<T>[]): Observable<T>;	// alias for catch
 
 		combineLatest<T, T2, TResult>(first: Observable<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
 		combineLatest<T, T2, TResult>(first: IPromise<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
diff --git a/rx/rx.async-lite.d.ts b/rx/rx.async-lite.d.ts
index 77dc23b57..f86dc326f 100644
--- a/rx/rx.async-lite.d.ts
+++ b/rx/rx.async-lite.d.ts
@@ -6,6 +6,13 @@
 ///<reference path="rx-lite.d.ts"/>
 
 declare module Rx {
+	export module config {
+		/**
+		* Configuration option to determine whether to use native events only
+		*/
+		export var useNativeEvents: boolean;
+	}
+
     interface ObservableStatic {
 		/**
 		* Invokes the asynchronous function, surfacing the result through an observable sequence.
diff --git a/rx/rx.backpressure-lite.d.ts b/rx/rx.backpressure-lite.d.ts
index d1c244195..9d4027be6 100644
--- a/rx/rx.backpressure-lite.d.ts
+++ b/rx/rx.backpressure-lite.d.ts
@@ -15,8 +15,7 @@ declare module Rx {
 		* @param pauser The observable sequence used to pause the underlying sequence.
 		* @returns The observable sequence which is paused based upon the pauser.
 		*/
-		pausable(pauser: Observable<boolean>): Observable<T>;
-		pausable(pauser?: ISubject<boolean>): PausableObservable<T>;
+		pausable(pauser?: Observable<boolean>): PausableObservable<T>;
 
 		/**
 		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
@@ -27,7 +26,7 @@ declare module Rx {
 		* @param pauser The observable sequence used to pause the underlying sequence.
 		* @returns The observable sequence which is paused based upon the pauser.
 		*/
-		pausableBuffered(pauser?: ISubject<boolean>): PausableObservable<T>;
+		pausableBuffered(pauser?: Observable<boolean>): PausableObservable<T>;
 
 		/**
 		* Attaches a controller to the observable sequence with the ability to queue.
diff --git a/rx/rx.backpressure.d.ts b/rx/rx.backpressure.d.ts
index 9c5e8abd5..18ab4ddd9 100644
--- a/rx/rx.backpressure.d.ts
+++ b/rx/rx.backpressure.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS-BackPressure v2.2.28
+// Type definitions for RxJS-BackPressure v2.3.12
 // Project: http://rx.codeplex.com/
 // Definitions by: Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
diff --git a/rx/rx.d.ts b/rx/rx.d.ts
index 1f26a94a9..73c97bbc9 100644
--- a/rx/rx.d.ts
+++ b/rx/rx.d.ts
@@ -11,19 +11,7 @@ declare module Rx {
 		catchException(handler: (exception: any) => boolean): 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;
-
+    export interface Scheduler extends IScheduler {
 		now(): number;
 		catch(handler: (exception: any) => boolean): IScheduler;
 		catchException(handler: (exception: any) => boolean): IScheduler;
@@ -46,7 +34,22 @@ declare module Rx {
 		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
 	}
 
-	// Observer
+    interface SchedulerStatic {
+        new (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): Scheduler;
+
+        normalize(timeSpan: number): number;
+
+        immediate: IScheduler;
+        currentThread: ICurrentThreadScheduler;
+        timeout: IScheduler;
+    }
+
+    export var Scheduler: SchedulerStatic;
+
+    // Observer
 	export interface Observer<T> {
 		checked(): Observer<any>;
 	}
diff --git a/rx/rx.joinpatterns.d.ts b/rx/rx.joinpatterns.d.ts
index 929c66a6f..ce251a2db 100644
--- a/rx/rx.joinpatterns.d.ts
+++ b/rx/rx.joinpatterns.d.ts
@@ -9,45 +9,45 @@ declare module Rx {
 
 	interface Pattern1<T1> {
 		and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
-		then<TR>(selector: (item1: T1) => TR): Plan<TR>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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>;
+		thenDo<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<T> {
 		and<T2>(other: Observable<T2>): Pattern2<T, T2>;
-		then<TR>(selector: (item1: T) => TR): Plan<TR>;
+		thenDo<TR>(selector: (item1: T) => TR): Plan<TR>;
 	}
 
 	interface ObservableStatic {
diff --git a/rx/rx.time-lite.d.ts b/rx/rx.time-lite.d.ts
index 7a7d8f46f..3642377f8 100644
--- a/rx/rx.time-lite.d.ts
+++ b/rx/rx.time-lite.d.ts
@@ -17,6 +17,7 @@ declare module Rx {
 	}
 
 	export interface Observable<T> {
+		delay(dueTime: Date, scheduler?: IScheduler): Observable<T>;
 		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
 		throttle(dueTime: number, scheduler?: IScheduler): Observable<T>;
 		timeInterval(scheduler?: IScheduler): Observable<TimeInterval<T>>;
@@ -25,25 +26,6 @@ declare module Rx {
 		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): Observable<T>;
-		delayWithSelector(delayDurationSelector: (item: T) => number): Observable<T>;
-		delayWithSelector(subscriptionDelay: number, delayDurationSelector: (item: T) => number): Observable<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): Observable<T>;
-		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<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): Observable<T>;
-		skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
-		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
-		takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
 	}
 
 	interface ObservableStatic {
@@ -51,12 +33,5 @@ declare module Rx {
 		interval(dutTime: number, period: number, scheduler?: IScheduler): Observable<number>;
 		timer(dueTime: number, period: number, scheduler?: IScheduler): Observable<number>;
 		timer(dueTime: number, scheduler?: IScheduler): Observable<number>;
-		generateWithRelativeTime<TState, TResult>(
-			initialState: TState,
-			condition: (state: TState) => boolean,
-			iterate: (state: TState) => TState,
-			resultSelector: (state: TState) => TResult,
-			timeSelector: (state: TState) => number,
-			scheduler?: IScheduler): Observable<TResult>;
 	}
 }
diff --git a/rx/rx.time.d.ts b/rx/rx.time.d.ts
index 2cdb1d56a..3da66b95c 100644
--- a/rx/rx.time.d.ts
+++ b/rx/rx.time.d.ts
@@ -8,6 +8,25 @@
 
 declare module Rx {
 	export interface Observable<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: 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): Observable<T>;
+		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<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): Observable<T>;
+		skipUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+		takeUntilWithTime(endTime: Date, scheduler?: IScheduler): Observable<T>;
+		takeUntilWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
+
 		windowWithTime(timeSpan: number, timeShift: number, scheduler?: IScheduler): Observable<Observable<T>>;
 		windowWithTime(timeSpan: number, scheduler?: IScheduler): Observable<Observable<T>>;
 		windowWithTimeOrCount(timeSpan: number, count: number, scheduler?: IScheduler): Observable<Observable<T>>;
@@ -20,6 +39,13 @@ declare module Rx {
 		timer(dueTime: Date, period: number, scheduler?: IScheduler): Observable<number>;
 		timer(dueTime: Date, scheduler?: IScheduler): Observable<number>;
 
+		generateWithRelativeTime<TState, TResult>(
+			initialState: TState,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => number,
+			scheduler?: IScheduler): Observable<TResult>;
 		generateWithAbsoluteTime<TState, TResult>(
 			initialState: TState,
 			condition: (state: TState) => boolean,