diff --git a/rx/rx-lite.d.ts b/rx/rx-lite.d.ts
index 3ea8c6ed88..851545fb80 100644
--- a/rx/rx-lite.d.ts
+++ b/rx/rx-lite.d.ts
@@ -50,7 +50,6 @@ declare module Rx {
 	export module helpers {
 		function noop(): void;
 		function notDefined(value: any): boolean;
-		function isScheduler(value: any): boolean;
 		function identity<T>(value: T): T;
 		function defaultNow(): number;
 		function defaultComparer(left: any, right: any): boolean;
@@ -117,6 +116,7 @@ declare module Rx {
 
 	export interface IScheduler {
 		now(): number;
+	  isScheduler(value: any): boolean;
 
 		schedule(action: () => void): IDisposable;
 		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
@@ -241,6 +241,23 @@ declare module Rx {
 		combineLatest<T2, T3, T4, T5, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
 		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
 		combineLatest<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+		withLatestFrom<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T2, TResult>(second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, TResult>(second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<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>;
+		withLatestFrom<T2, T3, T4, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T2, T3, T4, TResult>(second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<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>;
+		withLatestFrom<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
+		withLatestFrom<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (firstValue: T, ...otherValues: TOther[]) => TResult): Observable<TResult>;
 		concat(...sources: Observable<T>[]): Observable<T>;
 		concat(...sources: IPromise<T>[]): Observable<T>;
 		concat(sources: Observable<T>[]): Observable<T>;
@@ -291,7 +308,7 @@ declare module Rx {
 		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>;
@@ -305,7 +322,7 @@ declare module Rx {
 		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, seed: TAcc) => TAcc): Observable<TAcc>;
 		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
 		skipLast(count: number): Observable<T>;
 		startWith(...values: T[]): Observable<T>;
@@ -322,12 +339,34 @@ declare module Rx {
 		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
 		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
 		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => TResult[]): Observable<TResult>;	// alias for selectMany
 		flatMap<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
 		flatMap<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(other: Observable<TResult>): Observable<TResult>;	// alias for selectMany
 		flatMap<TResult>(other: IPromise<TResult>): Observable<TResult>;	// alias for selectMany
+		flatMap<TResult>(selector: (value: T) => TResult[]): Observable<TResult>;	// alias for selectMany
+
+		/**
+		 * Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
+		 * @param {Function} onNext A transform function to apply to each element; the second parameter of the function represents the index of the source element.
+		 * @param {Function} onError A transform function to apply when an error occurs in the source sequence.
+		 * @param {Function} onCompleted A transform function to apply when the end of the source sequence is reached.
+		 * @param {Any} [thisArg] An optional "this" to use to invoke each transform.
+		 * @returns {Observable} An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.
+		 */
+		selectManyObserver<T2, T3, T4>(onNext: (value: T, index: number) => Observable<T2>, onError: (exception: any) => Observable<T3>, onCompleted: () => Observable<T4>, thisArg?: any): Observable<T2 | T3 | T4>;
+
+		/**
+		 * Projects each notification of an observable sequence to an observable sequence and merges the resulting observable sequences into one observable sequence.
+		 * @param {Function} onNext A transform function to apply to each element; the second parameter of the function represents the index of the source element.
+		 * @param {Function} onError A transform function to apply when an error occurs in the source sequence.
+		 * @param {Function} onCompleted A transform function to apply when the end of the source sequence is reached.
+		 * @param {Any} [thisArg] An optional "this" to use to invoke each transform.
+		 * @returns {Observable} An observable sequence whose elements are the result of invoking the one-to-many transform function corresponding to each notification in the input sequence.
+		 */
+		flatMapObserver<T2, T3, T4>(onNext: (value: T, index: number) => Observable<T2>, onError: (exception: any) => Observable<T3>, onCompleted: () => Observable<T4>, thisArg?: any): Observable<T2 | T3 | T4>;
 
 		selectConcat<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;
 		selectConcat<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;
@@ -336,30 +375,30 @@ declare module Rx {
 		selectConcat<R>(sequence: Observable<R>): Observable<R>;
 
 		/**
-		*  Projects each element of an observable sequence into a new sequence of observable sequences by incorporating the element's index and then 
+		*  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.
 		* @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
 		* @param [thisArg] Object to use as this when executing callback.
-		* @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 
+		* @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>) => 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 
+		*  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.
 		* @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
 		* @param [thisArg] Object to use as this when executing callback.
-		* @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 
+		* @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>) => 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 
+		*  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.
 		* @param selector A transform function to apply to each source element; the second parameter of the function represents the index of the source element.
 		* @param [thisArg] Object to use as this when executing callback.
 		* @since 2.2.28
-		* @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 
+		* @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.
 		*/
 		switchMap<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for selectSwitch
@@ -383,7 +422,7 @@ declare module Rx {
 		* Converts an existing observable sequence to an ES6 Compatible Promise
 		* @example
 		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
-		* 
+		*
 		* // With config
 		* Rx.config.Promise = RSVP.Promise;
 		* var promise = Rx.Observable.return(42).toPromise();
@@ -470,36 +509,12 @@ declare module Rx {
 		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
 		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
 
-		/**
-		*  Converts an iterable into an Observable sequence
-		*  
-		* @example
-		*  var res = Rx.Observable.fromIterable(new Map());
-		*  var res = Rx.Observable.fromIterable(function* () { yield 42; });
-		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
-		* @param generator Generator to convert from.
-		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
-		* @returns The observable sequence whose elements are pulled from the given generator sequence.
-		*/
-		fromIterable<T>(generator: () => { next(): { done: boolean; value?: T; }; }, scheduler?: IScheduler): Observable<T>;
-
-		/**
-		*  Converts an iterable into an Observable sequence
-		*  
-		* @example
-		*  var res = Rx.Observable.fromIterable(new Map());
-		*  var res = Rx.Observable.fromIterable(new Set(), Rx.Scheduler.timeout);
-		* @param iterable Iterable to convert from.
-		* @param [scheduler] Scheduler to run the enumeration of the input sequence on.
-		* @returns The observable sequence whose elements are pulled from the given generator sequence.
-		*/
-		fromIterable<T>(iterable: {}, scheduler?: IScheduler): Observable<T>;	// todo: can't describe ES6 Iterable via TypeScript type system
 		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>;
 
 		/**
 		*  This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments.
-		* 
+		*
 		* @example
 		*  var res = Rx.Observable.of(1, 2, 3);
 		* @since 2.2.28
@@ -508,7 +523,7 @@ declare module Rx {
 		of<T>(...values: T[]): Observable<T>;
 
 		/**
-		*  This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments. 
+		*  This method creates a new Observable instance with a variable number of arguments, regardless of number or type of the arguments.
 		* @example
 		*  var res = Rx.Observable.ofWithScheduler(Rx.Scheduler.timeout, 1, 2, 3);
 		* @since 2.2.28
@@ -576,6 +591,38 @@ declare module Rx {
 		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
 		combineLatest<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
 
+		withLatestFrom<T, T2, TResult>(first: Observable<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, TResult>(first: IPromise<T>, second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, TResult>(first: Observable<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, TResult>(first: IPromise<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: Observable<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		withLatestFrom<T, T2, T3, T4, T5, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, fourth: Observable<T4>, fifth: Observable<T5>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4, v5: T5) => TResult): Observable<TResult>;
+		withLatestFrom<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+		withLatestFrom<TOther, TResult>(souces: IPromise<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+
 		concat<T>(...sources: Observable<T>[]): Observable<T>;
 		concat<T>(...sources: IPromise<T>[]): Observable<T>;
 		concat<T>(sources: Observable<T>[]): Observable<T>;
@@ -617,6 +664,8 @@ declare module Rx {
 		* @returns An Observable sequence which wraps the existing promise success and failure.
 		*/
 		fromPromise<T>(promise: IPromise<T>): Observable<T>;
+
+		prototype: any;
 	}
 
 	export var Observable: ObservableStatic;
@@ -625,11 +674,11 @@ declare module Rx {
 		hasObservers(): boolean;
 	}
 
-	export interface Subject<T> extends ISubject<T> {
-	}
+    export interface Subject<T> extends ISubject<T> {
+    }
 
-	interface SubjectStatic {
-		new <T>(): Subject<T>;
+    interface SubjectStatic {
+        new <T>(): Subject<T>;
 		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
 	}
 
diff --git a/rx/rx.aggregates.d.ts b/rx/rx.aggregates.d.ts
index 001d1b9932..313cb55917 100644
--- a/rx/rx.aggregates.d.ts
+++ b/rx/rx.aggregates.d.ts
@@ -40,17 +40,9 @@ declare module Rx {
 		sequenceEqual(second: T[]): Observable<boolean>;
 
 		elementAt(index: number): Observable<T>;
-		elementAtOrDefault(index: number, defaultValue?: T): Observable<T>;
-
 		single(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		singleOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
-
 		first(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		firstOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
-
 		last(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		lastOrDefault(predicate?: (value: T, index: number, source: Observable<T>) => boolean, defaultValue?: T, thisArg?: any): Observable<T>;
-
 		find(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
 		findIndex(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
 	}
@@ -58,4 +50,4 @@ declare module Rx {
 
 declare module "rx.aggregates" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.async-lite.d.ts b/rx/rx.async-lite.d.ts
index 94eb398007..8a725332f5 100644
--- a/rx/rx.async-lite.d.ts
+++ b/rx/rx.async-lite.d.ts
@@ -65,7 +65,9 @@ declare module Rx {
 			<T>(func: Function, context?: any): (...args: any[]) => Observable<T>;
 		};
 
-		fromEvent<T>(element: any, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
-        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
+		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEvent<T>(element: {on: (name: string, cb: (e: any) => any) => void; off: (name: string, cb: (e: any) => any) => void}, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
 	}
 }
diff --git a/rx/rx.async-tests.ts b/rx/rx.async-tests.ts
index 4f8c102c4a..6fe10526c7 100644
--- a/rx/rx.async-tests.ts
+++ b/rx/rx.async-tests.ts
@@ -81,4 +81,4 @@ module Rx.Tests.Async {
 	function startAsync() {
 		var o: Rx.Observable<string> = Rx.Observable.startAsync(() => <Rx.IPromise<string>>null);
 	}
-}
\ No newline at end of file
+}
diff --git a/rx/rx.async.d.ts b/rx/rx.async.d.ts
index 783f31d52b..f1af9a6000 100644
--- a/rx/rx.async.d.ts
+++ b/rx/rx.async.d.ts
@@ -40,4 +40,4 @@ declare module Rx {
 
 declare module "rx.async" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.backpressure.d.ts b/rx/rx.backpressure.d.ts
index 18ab4ddd95..549cd870a2 100644
--- a/rx/rx.backpressure.d.ts
+++ b/rx/rx.backpressure.d.ts
@@ -8,4 +8,4 @@
 
 declare module "rx.backpressure" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.binding-lite.d.ts b/rx/rx.binding-lite.d.ts
index f896e260db..86db8922cb 100644
--- a/rx/rx.binding-lite.d.ts
+++ b/rx/rx.binding-lite.d.ts
@@ -7,6 +7,7 @@
 
 declare module Rx {
 	export interface BehaviorSubject<T> extends Subject<T> {
+		getValue(): T;
 	}
 
 	interface BehaviorSubjectStatic {
@@ -43,10 +44,10 @@ declare module Rx {
 		/**
 		* Returns an observable sequence that shares a single subscription to the underlying sequence.
 		* This operator is a specialization of publish which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
-		* 
+		*
 		* @example
 		* var res = source.share();
-		* 
+		*
 		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
 		*/
 		share(): Observable<T>;
@@ -57,10 +58,10 @@ declare module Rx {
 		/**
 		* Returns an observable sequence that shares a single subscription to the underlying sequence and starts with an initialValue.
 		* This operator is a specialization of publishValue which creates a subscription when the number of observers goes from zero to one, then shares that subscription with all subsequent observers until the number of observers returns to zero, at which point the subscription is disposed.
-		* 
+		*
 		* @example
 		* var res = source.shareValue(42);
-		* 
+		*
 		* @param initialValue Initial value received by observers upon subscription.
 		* @returns An observable sequence that contains the elements of a sequence produced by multicasting the source sequence.
 		*/
diff --git a/rx/rx.binding.d.ts b/rx/rx.binding.d.ts
index b93411a528..2bd4c5b01f 100644
--- a/rx/rx.binding.d.ts
+++ b/rx/rx.binding.d.ts
@@ -8,4 +8,4 @@
 
 declare module "rx.binding" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.coincidence-lite.d.ts b/rx/rx.coincidence-lite.d.ts
index 801e42168c..ca1cc73473 100644
--- a/rx/rx.coincidence-lite.d.ts
+++ b/rx/rx.coincidence-lite.d.ts
@@ -9,24 +9,24 @@ declare module Rx {
 
 	interface Observable<T> {
 		/**
-		* Returns a new observable that triggers on the second and subsequent triggerings of the input observable. 
-		* The Nth triggering of the input observable passes the arguments from the N-1th and Nth triggering as a pair. 
+		* Returns a new observable that triggers on the second and subsequent triggerings of the input observable.
+		* The Nth triggering of the input observable passes the arguments from the N-1th and Nth triggering as a pair.
 		* The argument passed to the N-1th triggering is held in hidden internal state until the Nth triggering occurs.
 		* @returns An observable that triggers on successive pairs of observations from the input observable as an array.
 		*/
 		pairwise(): Observable<T[]>;
 
-		/** 
+		/**
 		* Returns two observables which partition the observations of the source by the given function.
-		* The first will trigger observations for those values for which the predicate returns true. 
-		* The second will trigger observations for those values where the predicate returns false. 
-		* The predicate is executed once for each subscribed observer. 
-		* Both also propagate all error observations arising from the source and each completes 
+		* The first will trigger observations for those values for which the predicate returns true.
+		* The second will trigger observations for those values where the predicate returns false.
+		* The predicate is executed once for each subscribed observer.
+		* Both also propagate all error observations arising from the source and each completes
 		* when the source completes.
-		* @param predicate 
+		* @param predicate
 		*    The function to determine which output Observable will trigger a particular observation.
 		* @returns
-		*    An array of observables. The first triggers when the predicate returns true, 
+		*    An array of observables. The first triggers when the predicate returns true,
 		*    and the second triggers when the predicate returns false.
 		*/
 		partition(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg: any): Observable<T>[];
diff --git a/rx/rx.coincidence.d.ts b/rx/rx.coincidence.d.ts
index 87fa6a55b5..d06166224a 100644
--- a/rx/rx.coincidence.d.ts
+++ b/rx/rx.coincidence.d.ts
@@ -33,4 +33,4 @@ declare module Rx {
 
 declare module "rx.coincidence" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.d.ts b/rx/rx.d.ts
index f1dc527d76..9b806119e4 100644
--- a/rx/rx.d.ts
+++ b/rx/rx.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for RxJS v2.2.28
+// Type definitions for RxJS v2.5.3
 // Project: http://rx.codeplex.com/
 // Definitions by: gsino <http://www.codeplex.com/site/users/view/gsino>, Igor Oleinikov <https://github.com/Igorbek>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -39,7 +39,7 @@ declare module Rx {
 		distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
 		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
 		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
-		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
 		groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
 		groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
 	}
diff --git a/rx/rx.experimental.d.ts b/rx/rx.experimental.d.ts
index 60aec86e1a..e80ca03294 100644
--- a/rx/rx.experimental.d.ts
+++ b/rx/rx.experimental.d.ts
@@ -29,13 +29,13 @@ declare module Rx {
 		/**
 		 *  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. 
+		 * @returns An observable sequence which is repeated as long as the condition holds.
 		 */
 		doWhile(condition: () => boolean): Observable<T>;
 
 		/**
 		 *  Expands an observable sequence by recursively invoking selector.
-		 *  
+		 *
 		 * @param selector Selector function to invoke for each produced element, resulting in another sequence to which the selector will be invoked recursively again.
 		 * @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.
@@ -64,7 +64,7 @@ declare module Rx {
 	interface ObservableStatic {
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, obs2);
 		 * @param condition The condition which determines if the thenSource or elseSource will be run.
@@ -79,7 +79,7 @@ declare module Rx {
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, scheduler);
 		 * @param condition The condition which determines if the thenSource or empty sequence will be run.
@@ -92,7 +92,7 @@ declare module Rx {
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, obs2);
 		 * @param condition The condition which determines if the thenSource or elseSource will be run.
@@ -107,7 +107,7 @@ declare module Rx {
 
 		/**
 		 *  Determines whether an observable collection contains values. There is an alias for this method called 'ifThen' for browsers <IE9
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.if(condition, obs1, scheduler);
 		 * @param condition The condition which determines if the thenSource or empty sequence will be run.
@@ -123,7 +123,7 @@ declare module Rx {
 		 * There is an alias for this method called 'forIn' for browsers <IE9
 		 * @param sources An array of values to turn into an observable sequence.
 		 * @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.  
+		 * @returns An observable sequence from the concatenated observable sequences.
 		 */
 		for<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
 
@@ -132,7 +132,7 @@ declare module Rx {
 		 * There is an alias for this method called 'forIn' for browsers <IE9
 		 * @param sources An array of values to turn into an observable sequence.
 		 * @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.  
+		 * @returns An observable sequence from the concatenated observable sequences.
 		 */
 		forIn<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
 
@@ -141,7 +141,7 @@ declare module Rx {
 		 * There is an alias for this method called 'whileDo' for browsers <IE9
 		 * @param condition The condition which determines if the source will be repeated.
 		 * @param source The observable sequence or promise that will be run if the condition function returns true.
-		 * @returns An observable sequence which is repeated as long as the condition holds.  
+		 * @returns An observable sequence which is repeated as long as the condition holds.
 		 */
 		while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
 		while<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
@@ -151,7 +151,7 @@ declare module Rx {
 		 * There is an alias for this method called 'whileDo' for browsers <IE9
 		 * @param condition The condition which determines if the source will be repeated.
 		 * @param source The observable sequence or promise that will be run if the condition function returns true.
-		 * @returns An observable sequence which is repeated as long as the condition holds.  
+		 * @returns An observable sequence which is repeated as long as the condition holds.
 		 */
 		whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
 		whileDo<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
@@ -159,14 +159,14 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
@@ -176,16 +176,16 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
-		 * 
+		 *
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
@@ -193,14 +193,14 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
@@ -210,16 +210,16 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
-		 * 
+		 *
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
@@ -227,14 +227,14 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
@@ -244,16 +244,16 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
-		 * 
+		 *
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
@@ -261,14 +261,14 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, obs0);
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param elseSource The observable sequence or promise that will be run if the sources are not matched.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: Observable<T>): Observable<T>;
 		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: Observable<T>): Observable<T>;
@@ -278,23 +278,23 @@ declare module Rx {
 		/**
 		 *  Uses selector to determine which source in sources to use.
 		 *  There is an alias 'switchCase' for browsers <IE9.
-		 *  
+		 *
 		 * @example
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 });
 		 *  res = Rx.Observable.case(selector, { '1': obs1, '2': obs2 }, scheduler);
-		 * 
+		 *
 		 * @param selector The function which extracts the value for to test in a case statement.
 		 * @param sources A object which has keys which correspond to the case statement labels.
 		 * @param scheduler Scheduler used to create Rx.Observabe.Empty.
-		 *       
-		 * @returns An observable sequence which is determined by a case statement.  
+		 *
+		 * @returns An observable sequence which is determined by a case statement.
 		 */
 		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, scheduler?: IScheduler): Observable<T>;
 		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.forkJoin([obs1, obs2]);
 		 * @param sources Array of source sequences or promises.
@@ -305,7 +305,7 @@ declare module Rx {
 
 		/**
 		 *  Runs all observable sequences in parallel and collect their last elements.
-		 *  
+		 *
 		 * @example
 		 * res = Rx.Observable.forkJoin(obs1, obs2, ...);
 		 * @param args Source sequences or promises.
@@ -318,4 +318,4 @@ declare module Rx {
 
 declare module "rx.experimental" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.joinpatterns.d.ts b/rx/rx.joinpatterns.d.ts
index ce251a2db7..fc20f82547 100644
--- a/rx/rx.joinpatterns.d.ts
+++ b/rx/rx.joinpatterns.d.ts
@@ -57,4 +57,4 @@ declare module Rx {
 
 declare module "rx.joinpatterns" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.lite.d.ts b/rx/rx.lite.d.ts
index f6785a1a75..66ec678498 100644
--- a/rx/rx.lite.d.ts
+++ b/rx/rx.lite.d.ts
@@ -12,4 +12,4 @@
 
 declare module "rx.lite" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.testing.d.ts b/rx/rx.testing.d.ts
index 466243784f..58b074f756 100644
--- a/rx/rx.testing.d.ts
+++ b/rx/rx.testing.d.ts
@@ -61,4 +61,4 @@ declare module Rx {
 
 declare module "rx.testing" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.time-lite.d.ts b/rx/rx.time-lite.d.ts
index 3642377f82..f7a902685e 100644
--- a/rx/rx.time-lite.d.ts
+++ b/rx/rx.time-lite.d.ts
@@ -19,11 +19,21 @@ declare module Rx {
 	export interface Observable<T> {
 		delay(dueTime: Date, scheduler?: IScheduler): Observable<T>;
 		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
+
+		debounce(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		throttleWithTimeout(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		/**
+		* @deprecated use #debounce or #throttleWithTimeout instead.
+		*/
 		throttle(dueTime: 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>;
 	}
diff --git a/rx/rx.time.d.ts b/rx/rx.time.d.ts
index 3da66b95c5..2e3ea0a090 100644
--- a/rx/rx.time.d.ts
+++ b/rx/rx.time.d.ts
@@ -13,7 +13,12 @@ declare module Rx {
 		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>;
+
+		debounceWithSelector<TTimeout>(debounceDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
+		/**
+		* @deprecated use #debounceWithSelector instead.
+		*/
+		throttleWithSelector<TTimeout>(debounceDurationSelector: (item: T) => Observable<TTimeout>): Observable<T>;
 
 		skipLastWithTime(duration: number, scheduler?: IScheduler): Observable<T>;
 		takeLastWithTime(duration: number, timerScheduler?: IScheduler, loopScheduler?: IScheduler): Observable<T>;
@@ -58,4 +63,4 @@ declare module Rx {
 
 declare module "rx.time" {
 	export = Rx;
-}
\ No newline at end of file
+}
diff --git a/rx/rx.virtualtime.d.ts b/rx/rx.virtualtime.d.ts
index 25e8940746..bac31a0d37 100644
--- a/rx/rx.virtualtime.d.ts
+++ b/rx/rx.virtualtime.d.ts
@@ -38,4 +38,4 @@ declare module Rx {
 
 declare module "rx.virtualtime" {
 	export = Rx;
-}
\ No newline at end of file
+}