From 439b1fdf0469b7488988318be9dbee6c71fa8ab7 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Mon, 21 Jul 2014 18:11:26 -0700
Subject: [PATCH 01/11] rx.js renamed to rx.

---
 rx-lite.d.ts              | 565 ++++++++++++++++++++++++++++++++++++++
 rx.aggregates.d.ts        |  61 ++++
 rx.all.ts                 |  20 ++
 rx.async-lite.d.ts        |  65 +++++
 rx.async-tests.ts         |  88 ++++++
 rx.async.d.ts             |  43 +++
 rx.backpressure-lite.d.ts |  49 ++++
 rx.backpressure-tests.ts  |  22 ++
 rx.backpressure.d.ts      |  11 +
 rx.binding-lite.d.ts      |  72 +++++
 rx.binding.d.ts           |  11 +
 rx.coincidence-lite.d.ts  |  34 +++
 rx.coincidence.d.ts       |  36 +++
 rx.d.ts                   | 102 +++++++
 rx.experimental.d.ts      | 321 ++++++++++++++++++++++
 rx.joinpatterns.d.ts      |  60 ++++
 rx.lite.d.ts              |  50 ++++
 rx.testing.d.ts           |  62 +++++
 rx.time-lite.d.ts         |  62 +++++
 rx.time.d.ts              |  35 +++
 rx.virtualtime.d.ts       |  39 +++
 21 files changed, 1808 insertions(+)
 create mode 100644 rx-lite.d.ts
 create mode 100644 rx.aggregates.d.ts
 create mode 100644 rx.all.ts
 create mode 100644 rx.async-lite.d.ts
 create mode 100644 rx.async-tests.ts
 create mode 100644 rx.async.d.ts
 create mode 100644 rx.backpressure-lite.d.ts
 create mode 100644 rx.backpressure-tests.ts
 create mode 100644 rx.backpressure.d.ts
 create mode 100644 rx.binding-lite.d.ts
 create mode 100644 rx.binding.d.ts
 create mode 100644 rx.coincidence-lite.d.ts
 create mode 100644 rx.coincidence.d.ts
 create mode 100644 rx.d.ts
 create mode 100644 rx.experimental.d.ts
 create mode 100644 rx.joinpatterns.d.ts
 create mode 100644 rx.lite.d.ts
 create mode 100644 rx.testing.d.ts
 create mode 100644 rx.time-lite.d.ts
 create mode 100644 rx.time.d.ts
 create mode 100644 rx.virtualtime.d.ts

diff --git a/rx-lite.d.ts b/rx-lite.d.ts
new file mode 100644
index 000000000..c7a148137
--- /dev/null
+++ b/rx-lite.d.ts
@@ -0,0 +1,565 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+declare module Rx {
+	export module internals {
+		function isEqual(left: any, right: any): boolean;
+		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
+
+		// Priority Queue for Scheduling
+		export class PriorityQueue<TTime> {
+			constructor(capacity: number);
+
+			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;
+
+			static count: number;
+		}
+
+		export class ScheduledItem<TTime> {
+			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => 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 module config {
+		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
+	}
+
+	export module helpers {
+		function noop(): void;
+		function identity<T>(value: T): T;
+		function defaultNow(): number;
+		function defaultComparer(left: any, right: any): boolean;
+		function defaultSubComparer(left: any, right: any): number;
+		function defaultKeySerializer(key: any): string;
+		function defaultError(err: any): void;
+		function isPromise(p: any): boolean;
+		function asArray<T>(...args: T[]): T[];
+		function not(value: any): boolean;
+	}
+
+	export interface IDisposable {
+		dispose(): void;
+	}
+
+	export class CompositeDisposable implements IDisposable {
+		constructor (...disposables: IDisposable[]);
+		constructor (disposables: IDisposable[]);
+
+		isDisposed: boolean;
+		length: number;
+
+		dispose(): void;
+		add(item: IDisposable): void;
+		remove(item: IDisposable): boolean;
+		clear(): void;
+		contains(item: IDisposable): boolean;
+		toArray(): IDisposable[];
+	}
+
+	export class Disposable implements IDisposable {
+		constructor(action: () => void);
+
+		static create(action: () => void): IDisposable;
+		static empty: IDisposable;
+
+		dispose(): void;
+	}
+
+	// Single assignment
+	export class SingleAssignmentDisposable implements IDisposable {
+		constructor();
+
+		isDisposed: boolean;
+		current: IDisposable;
+
+		dispose(): void ;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void ;
+	}
+
+	// Multiple assignment disposable
+	export class SerialDisposable implements IDisposable {
+		constructor();
+
+		isDisposed: boolean;
+
+		dispose(): void;
+		getDisposable(): IDisposable;
+		setDisposable(value: IDisposable): void;
+	}
+
+	export class RefCountDisposable implements IDisposable {
+		constructor(disposable: IDisposable);
+
+		dispose(): void;
+
+		isDisposed: boolean;
+		getDisposable(): IDisposable;
+	}
+
+	export interface IScheduler {
+		now(): number;
+
+		schedule(action: () => void): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () =>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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
+	}
+
+	// Current Thread IScheduler
+	interface ICurrentThreadScheduler extends IScheduler {
+		scheduleRequired(): boolean;
+	}
+
+	// Notifications
+	export class Notification<T> {
+		accept(observer: IObserver<T>): void;
+		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
+		toObservable(scheduler?: IScheduler): Observable<T>;
+		hasValue: boolean;
+		equals(other: Notification<T>): boolean;
+		kind: string;
+		value: T;
+		exception: any;
+
+		static createOnNext<T>(value: T): Notification<T>;
+		static createOnError<T>(exception: any): Notification<T>;
+		static createOnCompleted<T>(): Notification<T>;
+	}
+
+	/**
+	 * Promise A+
+	 */
+	export interface IPromise<T> {
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
+		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
+		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
+	}
+
+	// Observer
+	export interface IObserver<T> {
+		onNext(value: T): void;
+		onError(exception: any): void;
+		onCompleted(): void;
+	}
+
+	export interface Observer<T> extends IObserver<T> {
+		toNotifier(): (notification: Notification<T>) => void;
+		asObserver(): Observer<T>;
+	}
+
+	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>;
+	}
+
+	export var Observer: ObserverStatic;
+
+	export interface IObservable<T> {
+		subscribe(observer: Observer<T>): IDisposable;
+		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
+	}
+
+	export interface Observable<T> extends IObservable<T> {
+		forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;	// alias for subscribe
+		toArray(): Observable<T[]>;
+
+		catch(handler: (exception: any) => Observable<T>): Observable<T>;
+		catchException(handler: (exception: any) => Observable<T>): Observable<T>;	// alias for catch
+		catch(handler: (exception: any) => IPromise<T>): Observable<T>;
+		catchException(handler: (exception: any) => IPromise<T>): Observable<T>;	// alias for catch
+		catch(second: Observable<T>): Observable<T>;
+		catchException(second: Observable<T>): Observable<T>;	// alias for catch
+		combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T2, TResult>(second: IPromise<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, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<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, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		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>;
+		concat(...sources: Observable<T>[]): Observable<T>;
+		concat(...sources: IPromise<T>[]): Observable<T>;
+		concat(sources: Observable<T>[]): Observable<T>;
+		concat(sources: IPromise<T>[]): Observable<T>;
+		concatAll(): T;
+		concatObservable(): T;	// alias for concatAll
+		concatMap<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;	// alias for selectConcat
+		concatMap<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;	// alias for selectConcat
+		concatMap<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;	// alias for selectConcat
+		concatMap<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;	// alias for selectConcat
+		concatMap<R>(sequence: Observable<R>): Observable<R>;	// alias for selectConcat
+		merge(maxConcurrent: number): T;
+		merge(other: Observable<T>): Observable<T>;
+		merge(other: IPromise<T>): Observable<T>;
+		mergeAll(): T;
+		mergeObservable(): T;	// alias for mergeAll
+		skipUntil<T2>(other: Observable<T2>): Observable<T>;
+		skipUntil<T2>(other: IPromise<T2>): Observable<T>;
+		switch(): T;
+		switchLatest(): T;	// alias for switch
+		takeUntil<T2>(other: Observable<T2>): Observable<T>;
+		takeUntil<T2>(other: IPromise<T2>): Observable<T>;
+		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		zip<T2, TResult>(second: IPromise<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, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		zip<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<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, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
+		zip<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>;
+		zip<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>;
+		zip<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>;
+		zip<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>;
+		zip<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>;
+		zip<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>;
+		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<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
+		zip<TOther, TResult>(second: IPromise<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
+
+		asObservable(): Observable<T>;
+		dematerialize<TOrigin>(): Observable<TOrigin>;
+		distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
+		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
+		do(observer: Observer<T>): Observable<T>;
+		doAction(observer: Observer<T>): Observable<T>;	// alias for do
+		do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
+		doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
+		finally(action: () => void): Observable<T>;
+		finallyAction(action: () => void): Observable<T>;	// alias for finally
+		ignoreElements(): Observable<T>;
+		materialize(): Observable<Notification<T>>;
+		repeat(repeatCount?: number): Observable<T>;
+		retry(retryCount?: number): Observable<T>;
+		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
+		skipLast(count: number): Observable<T>;
+		startWith(...values: T[]): Observable<T>;
+		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
+		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
+		takeLastBuffer(count: number): Observable<T[]>;
+
+		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
+		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
+		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
+		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
+		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
+
+		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>;
+		selectConcat<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;
+		selectConcat<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;
+		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 
+		*  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 
+		*  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>;
+		/**
+		*  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 
+		*  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
+		/**
+		*  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 
+		*  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
+
+		skip(count: number): Observable<T>;
+		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		take(count: number, scheduler?: IScheduler): Observable<T>;
+		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
+
+		/**
+		* Converts an existing observable sequence to an ES6 Compatible Promise
+		* @example
+		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
+		* @param promiseCtor The constructor of the promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
+		/**
+		* 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();
+		* @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
+		* @returns An ES6 compatible promise with the last value from the observable sequence.
+		*/
+		toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
+
+		// Experimental Flattening
+
+		/**
+		* Performs a exclusive waiting for the first to finish before subscribing to another observable.
+		* Observables that come in between subscriptions will be dropped on the floor.
+		* Can be applied on `Observable<Observable<R>>` or `Observable<IPromise<R>>`.
+		* @since 2.2.28
+		* @returns A exclusive observable with only the results that happen when subscribed.
+		*/
+		exclusive<R>(): Observable<R>;
+
+		/**
+		* Performs a exclusive map waiting for the first to finish before subscribing to another observable.
+		* Observables that come in between subscriptions will be dropped on the floor.
+		* Can be applied on `Observable<Observable<I>>` or `Observable<IPromise<I>>`.
+		* @since 2.2.28
+		* @param selector Selector to invoke for every item in the current subscription.
+		* @param [thisArg] An optional context to invoke with the selector parameter.
+		* @returns {An exclusive observable with only the results that happen when subscribed.
+		*/
+		exclusiveMap<I, R>(selector: (value: I, index: number, source: Observable<I>) => R, thisArg?: any): Observable<R>;
+	}
+
+	interface ObservableStatic {
+		create<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
+		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>;
+		defer<T>(observableFactory: () => IPromise<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>;
+
+		/**
+		*  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.
+		*/
+		fromItreable<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.
+		*/
+		fromItreable<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
+		* @returns The observable sequence whose elements are pulled from the given arguments.
+		*/
+		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. 
+		* @example
+		*  var res = Rx.Observable.ofWithScheduler(Rx.Scheduler.timeout, 1, 2, 3);
+		* @since 2.2.28
+		* @param [scheduler] A scheduler to use for scheduling the arguments.
+		* @returns The observable sequence whose elements are pulled from the given arguments.
+		*/
+		ofWithScheduler<T>(scheduler?: IScheduler, ...values: 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>;
+		/**
+		 * @since 2.2.28
+		 */
+		just<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
+		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
+		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
+		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
+		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
+		throwException<T>(exception: 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
+		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
+
+		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>;
+		combineLatest<T, T2, TResult>(first: Observable<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, TResult>(first: IPromise<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<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>;
+		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
+		combineLatest<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>;
+		concat<T>(sources: IPromise<T>[]): Observable<T>;
+		merge<T>(...sources: Observable<T>[]): Observable<T>;
+		merge<T>(...sources: IPromise<T>[]): Observable<T>;
+		merge<T>(sources: Observable<T>[]): Observable<T>;
+		merge<T>(sources: IPromise<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
+		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
+
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(first: Observable<T1>, sources: IPromise<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
+		zip<T1, T2, TResult>(source1: Observable<T1>, source2: IPromise<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, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<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, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
+		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: IPromise<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[]>;
+
+		/**
+		* Converts a Promise to an Observable sequence
+		* @param promise An ES6 Compliant promise.
+		* @returns An Observable sequence which wraps the existing promise success and failure.
+		*/
+		fromPromise<T>(promise: IPromise<T>): Observable<T>;
+	}
+
+	export var Observable: ObservableStatic;
+
+	interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
+		hasObservers(): boolean;
+	}
+
+    export interface Subject<T> extends ISubject<T> {
+    }
+
+    interface SubjectStatic {
+        new <T>(): Subject<T>;
+		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
+	}
+
+	export var Subject: SubjectStatic;
+
+	export interface AsyncSubject<T> extends Subject<T> {
+	}
+
+	interface AsyncSubjectStatic {
+		new <T>(): AsyncSubject<T>;
+	}
+
+	export var AsyncSubject: AsyncSubjectStatic;
+}
diff --git a/rx.aggregates.d.ts b/rx.aggregates.d.ts
new file mode 100644
index 000000000..001d1b993
--- /dev/null
+++ b/rx.aggregates.d.ts
@@ -0,0 +1,61 @@
+// Type definitions for RxJS-Aggregates v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+
+declare module Rx {
+	export interface Observable<T> {
+		finalValue(): Observable<T>;
+		aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
+		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
+
+		reduce(accumulator: (acc: T, value: T) => T): Observable<T>;
+		reduce<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable<TAcc>;		// TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751
+
+		any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
+		some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;	// alias for any
+
+		isEmpty(): Observable<boolean>;
+		all(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;
+		every(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;	// alias for all
+		contains(value: T): Observable<boolean>;
+		contains<TOther>(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable<boolean>;
+		count(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
+		sum(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
+		minBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		minBy(keySelector: (item: T) => number): Observable<T>;
+		min(comparer?: (value1: T, value2: T) => number): Observable<T>;
+		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
+		maxBy(keySelector: (item: T) => number): Observable<T>;
+		max(comparer?: (value1: T, value2: T) => number): Observable<number>;
+		average(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
+
+		sequenceEqual<TOther>(second: Observable<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual<TOther>(second: IPromise<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		sequenceEqual(second: Observable<T>): Observable<boolean>;
+		sequenceEqual(second: IPromise<T>): Observable<boolean>;
+		sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
+		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>;
+	}
+}
+
+declare module "rx.aggregates" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.all.ts b/rx.all.ts
new file mode 100644
index 000000000..c546477b8
--- /dev/null
+++ b/rx.all.ts
@@ -0,0 +1,20 @@
+// Type definitions for RxJS-All v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="rx.d.ts"/> 
+/// <reference path="rx.aggregates.d.ts"/> 
+/// <reference path="rx.time.d.ts"/> 
+/// <reference path="rx.async.d.ts"/> 
+/// <reference path="rx.binding.d.ts"/> 
+/// <reference path="rx.coincidence.d.ts"/> 
+/// <reference path="rx.experimental.d.ts"/> 
+/// <reference path="rx.joinpatterns.d.ts"/> 
+/// <reference path="rx.virtualtime.d.ts"/> 
+/// <reference path="rx.testing.d.ts"/>
+/// <reference path="rx.backpressure.d.ts" />
+
+declare module "rx.all" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.async-lite.d.ts b/rx.async-lite.d.ts
new file mode 100644
index 000000000..be13320c2
--- /dev/null
+++ b/rx.async-lite.d.ts
@@ -0,0 +1,65 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.async.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.d.ts"/>
+
+declare module Rx {
+    interface ObservableStatic {
+		/**
+		* Invokes the asynchronous function, surfacing the result through an observable sequence.
+		* @param functionAsync Asynchronous function which returns a Promise to run.
+		* @returns An observable sequence exposing the function's result value, or an exception.
+		*/
+		startAsync<T>(functionAsync: () => IPromise<T>): Observable<T>;
+
+		fromCallback: {
+			// with single result callback without selector
+			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback with selector
+			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
+			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any callback without selector
+			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			// with any function with selector
+			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
+			// with any function without selector
+			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
+		};
+
+		fromNodeCallback: {
+			// with single result callback without selector
+			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
+			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
+			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
+			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
+			// with any callback with selector
+			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
+			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
+			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any callback without selector
+			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
+			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
+			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			// with any function with selector
+			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
+			// with any function without selector
+			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
+		};
+
+		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
+        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
+	}
+}
diff --git a/rx.async-tests.ts b/rx.async-tests.ts
new file mode 100644
index 000000000..9c3bce516
--- /dev/null
+++ b/rx.async-tests.ts
@@ -0,0 +1,88 @@
+// Tests for RxJS-Async TypeScript definitions
+// Tests by Igor Oleinikov <https://github.com/Igorbek>
+
+/// <reference path="rx.async.d.ts" />
+
+module Rx.Tests.Async {
+
+	var obsNum: Rx.Observable<number>;
+	var obsStr: Rx.Observable<string>;
+	var sch: Rx.IScheduler;
+
+	function start() {
+		obsNum = Rx.Observable.start(()=> 10, sch, obsStr);
+		obsNum = Rx.Observable.start(()=> 10, sch);
+		obsNum = Rx.Observable.start(()=> 10);
+	}
+
+	function toAsync() {
+		obsNum = Rx.Observable.toAsync(()=> 1, sch)();
+		obsNum = Rx.Observable.toAsync((a1: number)=> a1)(1);
+        obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number)=> a1 + a2.toFixed(0))("", 1);
+		obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number, a3: Date)=> a1 + a2.toFixed(0) + a3.toDateString())("", 1, new Date());
+        obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number, a3: Date, a4: boolean)=> a1 + a2.toFixed(0) + a3.toDateString() + (a4 ? 1 : 0))("", 1, new Date(), false);
+	}
+
+	function fromCallback() {
+		// 0 arguments
+		var func0: (cb: (result: number)=> void)=> void;
+		obsNum = Rx.Observable.fromCallback(func0)();
+		obsNum = Rx.Observable.fromCallback(func0, sch)();
+		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr)();
+		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr, (results: number[]) => results[0])();
+
+		// 1 argument
+		var func1: (a: string, cb: (result: number)=> void)=> number;
+		obsNum = Rx.Observable.fromCallback(func1)("");
+		obsNum = Rx.Observable.fromCallback(func1, sch)("");
+		obsNum = Rx.Observable.fromCallback(func1, sch, {})("");
+		obsNum = Rx.Observable.fromCallback(func1, sch, {}, (results: number[]) => results[0])("");
+
+		// 2 arguments
+		var func2: (a: number, b: string, cb: (result: string) => number) => Date;
+		obsStr = Rx.Observable.fromCallback(func2)(1, "");
+		obsStr = Rx.Observable.fromCallback(func2, sch)(1, "");
+		obsStr = Rx.Observable.fromCallback(func2, sch, {})(1, "");
+		obsStr = Rx.Observable.fromCallback(func2, sch, {}, (results: string[]) => results[0])(1, "");
+
+		// 3 arguments
+		var func3: (a: number, b: string, c: boolean, cb: (result: string) => number) => Date;
+		obsStr = Rx.Observable.fromCallback(func3)(1, "", true);
+		obsStr = Rx.Observable.fromCallback(func3, sch)(1, "", true);
+		obsStr = Rx.Observable.fromCallback(func3, sch, {})(1, "", true);
+		obsStr = Rx.Observable.fromCallback(func3, sch, {}, (results: string[]) => results[0])(1, "", true);
+
+		// multiple results
+		var func0m: (cb: (result1: number, result2: number, result3: number) => void) => void;
+		obsNum = Rx.Observable.fromCallback(func0m, sch, obsStr, (results: number[]) => results[0])();
+		var func1m: (a: string, cb: (result1: number, result2: number, result3: number) => void) => void;
+		obsNum = Rx.Observable.fromCallback(func1m, sch, obsStr, (results: number[]) => results[0])("");
+		var func2m: (a: string, b: number, cb: (result1: string, result2: string, result3: string) => void) => void;
+		obsStr = Rx.Observable.fromCallback(func2m, sch, obsStr, (results: string[]) => results[0])("", 10);
+	}
+
+	function toPromise() {
+		var promiseImpl: {
+			new<T>(resolver: (resolvePromise: (value: T)=> void, rejectPromise: (reason: any)=> void)=> void): Rx.IPromise<T>;
+		};
+
+		Rx.config.Promise = promiseImpl;
+
+		var p: IPromise<number> = obsNum.toPromise(promiseImpl);
+
+		p = obsNum.toPromise();
+
+		p = p.then(x=> x);
+		p = p.then(x=> p);
+		p = p.then(undefined, reason=> 10);
+		p = p.then(undefined, reason=> p);
+
+		var ps: IPromise<string> = p.then(undefined, reason=> "error");
+		ps = p.then(x=> "");
+		ps = p.then(x=> ps);
+	}
+
+	function startAsync() {
+		var o: Rx.Observable<string> = Rx.Observable.startAsync(() => <Rx.IPromise<string>>null);
+	}
+}
\ No newline at end of file
diff --git a/rx.async.d.ts b/rx.async.d.ts
new file mode 100644
index 000000000..9370c828b
--- /dev/null
+++ b/rx.async.d.ts
@@ -0,0 +1,43 @@
+// Type definitions for RxJS-Async v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: zoetrope <https://github.com/zoetrope>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.async-lite.d.ts" />
+
+declare module Rx {
+    interface ObservableStatic {
+		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
+
+        toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+	}
+}
+
+declare module "rx.async" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.backpressure-lite.d.ts b/rx.backpressure-lite.d.ts
new file mode 100644
index 000000000..d1c244195
--- /dev/null
+++ b/rx.backpressure-lite.d.ts
@@ -0,0 +1,49 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.backpressure.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.d.ts"/>
+
+declare module Rx {
+	export interface Observable<T> {
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausable(pauser);
+		* @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>;
+
+		/**
+		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
+		* and yields the values that were buffered while paused.
+		* @example
+		* var pauser = new Rx.Subject();
+		* var source = Rx.Observable.interval(100).pausableBuffered(pauser);
+		* @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>;
+
+		/**
+		* Attaches a controller to the observable sequence with the ability to queue.
+		* @example
+		* var source = Rx.Observable.interval(100).controlled();
+		* source.request(3); // Reads 3 values
+		*/
+		controlled(enableQueue?: boolean): ControlledObservable<T>;
+	}
+
+	export interface ControlledObservable<T> extends Observable<T> {
+		request(numberOfItems?: number): IDisposable;
+	}
+
+	export interface PausableObservable<T> extends Observable<T> {
+		pause(): void;
+		resume(): void;
+	}
+}
diff --git a/rx.backpressure-tests.ts b/rx.backpressure-tests.ts
new file mode 100644
index 000000000..f036a1dc3
--- /dev/null
+++ b/rx.backpressure-tests.ts
@@ -0,0 +1,22 @@
+// Tests for RxJS-BackPressure TypeScript definitions
+// Tests by Igor Oleinikov <https://github.com/Igorbek>
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.backpressure.d.ts" />
+
+function testPausable() {
+	var o: Rx.Observable<string>;
+
+	var pauser = new Rx.Subject<boolean>();
+
+	var p = o.pausable(pauser);
+	p = o.pausableBuffered(pauser);
+}
+
+function testControlled() {
+	var o: Rx.Observable<string>;
+	var c = o.controlled();
+
+	var d: Rx.IDisposable = c.request();
+	d = c.request(5);
+}
diff --git a/rx.backpressure.d.ts b/rx.backpressure.d.ts
new file mode 100644
index 000000000..9c5e8abd5
--- /dev/null
+++ b/rx.backpressure.d.ts
@@ -0,0 +1,11 @@
+// Type definitions for RxJS-BackPressure v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.backpressure-lite.d.ts" />
+
+declare module "rx.backpressure" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.binding-lite.d.ts b/rx.binding-lite.d.ts
new file mode 100644
index 000000000..f896e260d
--- /dev/null
+++ b/rx.binding-lite.d.ts
@@ -0,0 +1,72 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.d.ts"/>
+
+declare module Rx {
+	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>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
+	}
+
+	export var ReplaySubject: ReplaySubjectStatic;
+
+	interface ConnectableObservable<T> extends Observable<T> {
+		connect(): IDisposable;
+		refCount(): Observable<T>;
+    }
+
+    interface ConnectableObservableStatic {
+        new <T>(): ConnectableObservable<T>;
+	}
+
+	export var ConnectableObservable: ConnectableObservableStatic;
+
+	export interface Observable<T> {
+		multicast(subject: Observable<T>): ConnectableObservable<T>;
+		multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
+		publish(): ConnectableObservable<T>;
+		publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
+		/**
+		* 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>;
+		publishLast(): ConnectableObservable<T>;
+		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
+		publishValue(initialValue: T): ConnectableObservable<T>;
+		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
+		/**
+		* 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.
+		*/
+		shareValue(initialValue: T): Observable<T>;
+		replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;	// hack to catch first omitted parameter
+		replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
+		shareReplay(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
+	}
+}
diff --git a/rx.binding.d.ts b/rx.binding.d.ts
new file mode 100644
index 000000000..b93411a52
--- /dev/null
+++ b/rx.binding.d.ts
@@ -0,0 +1,11 @@
+// Type definitions for RxJS-Binding v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.binding-lite.d.ts" />
+
+declare module "rx.binding" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.coincidence-lite.d.ts b/rx.coincidence-lite.d.ts
new file mode 100644
index 000000000..801e42168
--- /dev/null
+++ b/rx.coincidence-lite.d.ts
@@ -0,0 +1,34 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.d.ts" />
+
+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. 
+		* 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 
+		* when the source completes.
+		* @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, 
+		*    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.coincidence.d.ts b/rx.coincidence.d.ts
new file mode 100644
index 000000000..87fa6a55b
--- /dev/null
+++ b/rx.coincidence.d.ts
@@ -0,0 +1,36 @@
+// Type definitions for RxJS-Coincidence v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.coincidence-lite.d.ts" />
+
+declare module Rx {
+
+	interface Observable<T> {
+		join<TRight, TDurationLeft, TDurationRight, TResult>(
+			right: Observable<TRight>,
+			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
+			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
+			resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable<TResult>;
+
+		groupJoin<TRight, TDurationLeft, TDurationRight, TResult>(
+			right: Observable<TRight>,
+			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
+			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
+			resultSelector: (leftItem: T, rightItem: Observable<TRight>) => TResult): Observable<TResult>;
+
+		window<TWindowOpening>(windowOpenings: Observable<TWindowOpening>): Observable<Observable<T>>;
+		window<TWindowClosing>(windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
+		window<TWindowOpening, TWindowClosing>(windowOpenings: Observable<TWindowOpening>, windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
+
+		buffer<TBufferOpening>(bufferOpenings: Observable<TBufferOpening>): Observable<T[]>;
+		buffer<TBufferClosing>(bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
+		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>, bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
+	}
+}
+
+declare module "rx.coincidence" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.d.ts b/rx.d.ts
new file mode 100644
index 000000000..1f26a94a9
--- /dev/null
+++ b/rx.d.ts
@@ -0,0 +1,102 @@
+// Type definitions for RxJS v2.2.28
+// 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
+
+///<reference path="rx-lite.d.ts"/>
+
+declare module Rx {
+	export interface IScheduler {
+		catch(handler: (exception: any) => boolean): IScheduler;
+		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;
+
+		now(): number;
+		catch(handler: (exception: any) => boolean): IScheduler;
+		catchException(handler: (exception: any) => boolean): IScheduler;
+
+		schedule(action: () => void): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () => 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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
+	}
+
+	// Observer
+	export interface Observer<T> {
+		checked(): Observer<any>;
+	}
+
+	interface ObserverStatic {
+		/**
+		* Schedules the invocation of observer methods on the given scheduler.
+		* @param scheduler Scheduler to schedule observer messages on.
+		* @returns Observer whose messages are scheduled on the given scheduler.
+		*/
+		notifyOn<T>(scheduler: IScheduler): Observer<T>;
+	}
+
+	export interface Observable<T> {
+		observeOn(scheduler: IScheduler): Observable<T>;
+		subscribeOn(scheduler: IScheduler): Observable<T>;
+
+		amb(rightSource: Observable<T>): Observable<T>;
+		amb(rightSource: IPromise<T>): Observable<T>;
+		onErrorResumeNext(second: Observable<T>): Observable<T>;
+		onErrorResumeNext(second: IPromise<T>): Observable<T>;
+		bufferWithCount(count: number, skip?: number): Observable<T[]>;
+		windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
+		defaultIfEmpty(defaultValue?: T): Observable<T>;
+		distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
+		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
+		groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
+	}
+
+	interface ObservableStatic {
+		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
+		amb<T>(...sources: Observable<T>[]): Observable<T>;
+		amb<T>(...sources: IPromise<T>[]): Observable<T>;
+		amb<T>(sources: Observable<T>[]): Observable<T>;
+		amb<T>(sources: IPromise<T>[]): Observable<T>;
+		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(...sources: IPromise<T>[]): Observable<T>;
+		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
+		onErrorResumeNext<T>(sources: IPromise<T>[]): Observable<T>;
+	}
+
+	interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
+		key: TKey;
+		underlyingObservable: Observable<TElement>;
+	}
+}
+
+declare module "rx" {
+    export = Rx
+}
diff --git a/rx.experimental.d.ts b/rx.experimental.d.ts
new file mode 100644
index 000000000..60aec86e1
--- /dev/null
+++ b/rx.experimental.d.ts
@@ -0,0 +1,321 @@
+// Type definitions for RxJS-Experimental v2.2.28
+// Project: https://github.com/Reactive-Extensions/RxJS/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="rx.d.ts"/>
+
+declare module Rx {
+
+	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.
+		 *
+		 * @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: 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.
+		 *  This operator allows for a fluent style of writing queries that use the same sequence multiple times.
+		 *
+		 * @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: 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): 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.
+		 */
+		expand(selector: (item: T) => Observable<T>, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		 *  Runs two observable sequences in parallel and combines their last elemenets.
+		 *
+		 * @param second Second observable sequence or promise.
+		 * @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: Observable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
+		forkJoin<TSecond, TResult>(second: IPromise<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
+
+		/**
+		 * Comonadic bind operator.
+		 * @param selector A transform function to apply to each element.
+		 * @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: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
+	}
+
+	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.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @param elseSource The observable sequence or promise 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: Observable<T>, elseSource: Observable<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @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: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		if<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		 *  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.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @param elseSource The observable sequence or promise 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: Observable<T>, elseSource: Observable<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.
+		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
+		 * @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: Observable<T>, scheduler?: IScheduler): Observable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
+
+		/**
+		 *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
+		 * 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.  
+		 */
+		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.
+		 * 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.  
+		 */
+		forIn<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
+
+		/**
+		 *  Repeats source as long as condition holds emulating a while loop.
+		 * 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.  
+		 */
+		while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
+		while<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
+
+		/**
+		 *  Repeats source as long as condition holds emulating a while loop.
+		 * 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.  
+		 */
+		whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
+		whileDo<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+
+		/**
+		 *  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.  
+		 */
+		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>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
+
+		/**
+		 *  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.  
+		 */
+		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.
+		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
+		 */
+		forkJoin<T>(sources: Observable<T>[]): Observable<T[]>;
+		forkJoin<T>(sources: IPromise<T>[]): Observable<T[]>;
+
+		/**
+		 *  Runs all observable sequences in parallel and collect their last elements.
+		 *  
+		 * @example
+		 * res = Rx.Observable.forkJoin(obs1, obs2, ...);
+		 * @param args Source sequences or promises.
+		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
+		 */
+		forkJoin<T>(...args: Observable<T>[]): Observable<T[]>;
+		forkJoin<T>(...args: IPromise<T>[]): Observable<T[]>;
+	}
+}
+
+declare module "rx.experimental" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.joinpatterns.d.ts b/rx.joinpatterns.d.ts
new file mode 100644
index 000000000..929c66a6f
--- /dev/null
+++ b/rx.joinpatterns.d.ts
@@ -0,0 +1,60 @@
+// Type definitions for RxJS-Join v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+
+declare module Rx {
+
+	interface Pattern1<T1> {
+		and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
+		then<TR>(selector: (item1: T1) => TR): Plan<TR>;
+	}
+	interface Pattern2<T1, T2> {
+		and<T3>(other: Observable<T3>): Pattern3<T1, T2, T3>;
+		then<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
+	}
+	interface Pattern3<T1, T2, T3> {
+		and<T4>(other: Observable<T4>): Pattern4<T1, T2, T3, T4>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
+	}
+	interface Pattern4<T1, T2, T3, T4> {
+		and<T5>(other: Observable<T5>): Pattern5<T1, T2, T3, T4, T5>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan<TR>;
+	}
+	interface Pattern5<T1, T2, T3, T4, T5> {
+		and<T6>(other: Observable<T6>): Pattern6<T1, T2, T3, T4, T5, T6>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan<TR>;
+	}
+	interface Pattern6<T1, T2, T3, T4, T5, T6> {
+		and<T7>(other: Observable<T7>): Pattern7<T1, T2, T3, T4, T5, T6, T7>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan<TR>;
+	}
+	interface Pattern7<T1, T2, T3, T4, T5, T6, T7> {
+		and<T8>(other: Observable<T8>): Pattern8<T1, T2, T3, T4, T5, T6, T7, T8>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan<TR>;
+	}
+	interface Pattern8<T1, T2, T3, T4, T5, T6, T7, T8> {
+		and<T9>(other: Observable<T9>): Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan<TR>;
+	}
+	interface Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan<TR>;
+	}
+
+	interface Plan<T> { }
+
+	interface Observable<T> {
+		and<T2>(other: Observable<T2>): Pattern2<T, T2>;
+		then<TR>(selector: (item1: T) => TR): Plan<TR>;
+	}
+
+	interface ObservableStatic {
+		when<TR>(plan: Plan<TR>): Observable<TR>;
+	}
+}
+
+declare module "rx.joinpatterns" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.lite.d.ts b/rx.lite.d.ts
new file mode 100644
index 000000000..046ef527d
--- /dev/null
+++ b/rx.lite.d.ts
@@ -0,0 +1,50 @@
+// Type definitions for RxJS-Lite v2.2.28
+// 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
+
+///<reference path="rx-lite.d.ts"/>
+///<reference path="rx.async-lite.d.ts" />
+///<reference path="rx.binding-lite.d.ts" />
+///<reference path="rx.time-lite.d.ts" />
+///<reference path="rx.backpressure-lite.d.ts" />
+///<reference path="rx.coincidence-lite.d.ts" />
+
+declare module Rx {
+	export class Scheduler implements IScheduler {
+		constructor(
+			now: () => number,
+			schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
+			scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable);
+
+		static normalize(timeSpan: number): number;
+
+		static immediate: IScheduler;
+		static currentThread: ICurrentThreadScheduler;
+		static timeout: IScheduler;
+
+		now(): number;
+
+		schedule(action: () => void): IDisposable;
+		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
+		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
+		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+
+		scheduleRecursive(action: (action: () => 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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
+
+		schedulePeriodic(period: number, action: () => void): IDisposable;
+		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
+	}
+}
+
+declare module "rx.lite" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.testing.d.ts b/rx.testing.d.ts
new file mode 100644
index 000000000..0adc83e50
--- /dev/null
+++ b/rx.testing.d.ts
@@ -0,0 +1,62 @@
+// Type definitions for RxJS-Testing v2.2.28
+// Project: https://github.com/Reactive-Extensions/RxJS/
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.virtualtime.d.ts" />
+
+declare module Rx {
+	export class TestScheduler extends VirtualTimeScheduler<number, number> {
+		constructor();
+
+		createColdObservable<T>(...records: Recorded[]): Observable<T>;
+		createHotObservable<T>(...records: Recorded[]): Observable<T>;
+		createObserver<T>(): MockObserver<T>;
+
+		startWithTiming<T>(create: () => Observable<T>, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver<T>;
+		startWithDispose<T>(create: () => Observable<T>, disposedAt: number): MockObserver<T>;
+		startWithCreate<T>(create: () => Observable<T>): MockObserver<T>;
+	}
+
+	export class Recorded {
+		constructor(time: number, value: any, equalityComparer?: (x: any, y: any) => boolean);
+		equals(other: Recorded): boolean;
+		toString(): string;
+		time: number;
+		value: any;
+	}
+
+	export var ReactiveTest: {
+		created: number;
+		subscribed: number;
+		disposed: number;
+
+		onNext(ticks: number, value: any): Recorded;
+		onNext(ticks: number, predicate: (value: any) => boolean): Recorded;
+		onError(ticks: number, exception: any): Recorded;
+		onError(ticks: number, predicate: (exception: any) => boolean): Recorded;
+		onCompleted(ticks: number): Recorded;
+
+		subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription;
+	};
+
+	export class Subscription {
+		constructor(subscribeAt: number, unsubscribeAt?: number);
+		equals(other: Subscription): boolean;
+	}
+
+	export interface MockObserver<T> extends Observer<T> {
+		messages: Recorded[];
+	}
+
+	interface MockObserverStatic extends ObserverStatic {
+		new <T>(scheduler: IScheduler): MockObserver<T>;
+	}
+
+	export var MockObserver: MockObserverStatic;
+}
+
+declare module "rx.testing" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.time-lite.d.ts b/rx.time-lite.d.ts
new file mode 100644
index 000000000..a5b102827
--- /dev/null
+++ b/rx.time-lite.d.ts
@@ -0,0 +1,62 @@
+// DefinitelyTyped: partial
+
+// This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
+// Do not include the file separately.
+
+///<reference path="rx-lite.d.ts" />
+
+declare module Rx {
+	export interface TimeInterval<T> {
+		value: T;
+		interval: number;
+	}
+
+	export interface Timestamp<T> {
+		value: T;
+		timestamp: number;
+	}
+
+	export interface Observable<T> {
+		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
+		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>;
+
+		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 {
+		interval(period: number, scheduler?: IScheduler): Observable<number>;
+		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.time.d.ts b/rx.time.d.ts
new file mode 100644
index 000000000..6efd7d9cf
--- /dev/null
+++ b/rx.time.d.ts
@@ -0,0 +1,35 @@
+// Type definitions for RxJS-Time v2.2.28
+// Project: http://rx.codeplex.com/
+// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path="rx.d.ts" />
+///<reference path="rx.time-lite.d.ts" />
+
+declare module Rx {
+	export interface 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>>;
+		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[]>;
+	}
+
+	interface ObservableStatic {
+		timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
+
+		generateWithAbsoluteTime<TState, TResult>(
+			initialState: TState,
+			condition: (state: TState) => boolean,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult,
+			timeSelector: (state: TState) => Date,
+			scheduler?: IScheduler): Observable<TResult>;
+	}
+}
+
+declare module "rx.time" {
+	export = Rx;
+}
\ No newline at end of file
diff --git a/rx.virtualtime.d.ts b/rx.virtualtime.d.ts
new file mode 100644
index 000000000..50a1bb39b
--- /dev/null
+++ b/rx.virtualtime.d.ts
@@ -0,0 +1,39 @@
+// Type definitions for RxJS-VirtualTime v2.2.28
+// 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
+
+///<reference path="rx.d.ts" />
+
+declare module Rx {
+    // Virtual IScheduler
+	export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
+		constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
+
+		advanceBy(time: TRelative): void;
+		advanceTo(time: TAbsolute): void;
+		scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable;
+		scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
+		scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
+		sleep(time: TRelative): void;
+		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);
+	}
+}
+
+declare module "rx.virtualtime" {
+	export = Rx;
+}
\ No newline at end of file

From 3854edf9c3d5172c6f5f70f783218543be6892fb Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 10:03:38 -0700
Subject: [PATCH 02/11] Added few helpers functions.

---
 rx/rx-lite.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rx/rx-lite.d.ts b/rx/rx-lite.d.ts
index c7a148137..eea3c55ce 100644
--- a/rx/rx-lite.d.ts
+++ b/rx/rx-lite.d.ts
@@ -49,6 +49,8 @@ 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;

From f9155131802b5062676acf94164e1f3c04e3c6c2 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 10:41:20 -0700
Subject: [PATCH 03/11] Removed rx files before merging.

---
 rx/rx-lite.d.ts              | 567 -----------------------------------
 rx/rx.aggregates.d.ts        |  61 ----
 rx/rx.all.ts                 |  20 --
 rx/rx.async-lite.d.ts        |  65 ----
 rx/rx.async-tests.ts         |  88 ------
 rx/rx.async.d.ts             |  43 ---
 rx/rx.backpressure-lite.d.ts |  49 ---
 rx/rx.backpressure-tests.ts  |  22 --
 rx/rx.backpressure.d.ts      |  11 -
 rx/rx.binding-lite.d.ts      |  72 -----
 rx/rx.binding.d.ts           |  11 -
 rx/rx.coincidence-lite.d.ts  |  34 ---
 rx/rx.coincidence.d.ts       |  36 ---
 rx/rx.d.ts                   | 102 -------
 rx/rx.experimental.d.ts      | 321 --------------------
 rx/rx.joinpatterns.d.ts      |  60 ----
 rx/rx.lite.d.ts              |  50 ---
 rx/rx.testing.d.ts           |  62 ----
 rx/rx.time-lite.d.ts         |  62 ----
 rx/rx.time.d.ts              |  35 ---
 rx/rx.virtualtime.d.ts       |  39 ---
 21 files changed, 1810 deletions(-)
 delete mode 100644 rx/rx-lite.d.ts
 delete mode 100644 rx/rx.aggregates.d.ts
 delete mode 100644 rx/rx.all.ts
 delete mode 100644 rx/rx.async-lite.d.ts
 delete mode 100644 rx/rx.async-tests.ts
 delete mode 100644 rx/rx.async.d.ts
 delete mode 100644 rx/rx.backpressure-lite.d.ts
 delete mode 100644 rx/rx.backpressure-tests.ts
 delete mode 100644 rx/rx.backpressure.d.ts
 delete mode 100644 rx/rx.binding-lite.d.ts
 delete mode 100644 rx/rx.binding.d.ts
 delete mode 100644 rx/rx.coincidence-lite.d.ts
 delete mode 100644 rx/rx.coincidence.d.ts
 delete mode 100644 rx/rx.d.ts
 delete mode 100644 rx/rx.experimental.d.ts
 delete mode 100644 rx/rx.joinpatterns.d.ts
 delete mode 100644 rx/rx.lite.d.ts
 delete mode 100644 rx/rx.testing.d.ts
 delete mode 100644 rx/rx.time-lite.d.ts
 delete mode 100644 rx/rx.time.d.ts
 delete mode 100644 rx/rx.virtualtime.d.ts

diff --git a/rx/rx-lite.d.ts b/rx/rx-lite.d.ts
deleted file mode 100644
index eea3c55ce..000000000
--- a/rx/rx-lite.d.ts
+++ /dev/null
@@ -1,567 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-declare module Rx {
-	export module internals {
-		function isEqual(left: any, right: any): boolean;
-		function addRef<T>(xs: Observable<T>, r: { getDisposable(): IDisposable; }): Observable<T>;
-
-		// Priority Queue for Scheduling
-		export class PriorityQueue<TTime> {
-			constructor(capacity: number);
-
-			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;
-
-			static count: number;
-		}
-
-		export class ScheduledItem<TTime> {
-			constructor(scheduler: IScheduler, state: any, action: (scheduler: IScheduler, state: any) => 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 module config {
-		export var Promise: { new <T>(resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; };
-	}
-
-	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;
-		function defaultSubComparer(left: any, right: any): number;
-		function defaultKeySerializer(key: any): string;
-		function defaultError(err: any): void;
-		function isPromise(p: any): boolean;
-		function asArray<T>(...args: T[]): T[];
-		function not(value: any): boolean;
-	}
-
-	export interface IDisposable {
-		dispose(): void;
-	}
-
-	export class CompositeDisposable implements IDisposable {
-		constructor (...disposables: IDisposable[]);
-		constructor (disposables: IDisposable[]);
-
-		isDisposed: boolean;
-		length: number;
-
-		dispose(): void;
-		add(item: IDisposable): void;
-		remove(item: IDisposable): boolean;
-		clear(): void;
-		contains(item: IDisposable): boolean;
-		toArray(): IDisposable[];
-	}
-
-	export class Disposable implements IDisposable {
-		constructor(action: () => void);
-
-		static create(action: () => void): IDisposable;
-		static empty: IDisposable;
-
-		dispose(): void;
-	}
-
-	// Single assignment
-	export class SingleAssignmentDisposable implements IDisposable {
-		constructor();
-
-		isDisposed: boolean;
-		current: IDisposable;
-
-		dispose(): void ;
-		getDisposable(): IDisposable;
-		setDisposable(value: IDisposable): void ;
-	}
-
-	// Multiple assignment disposable
-	export class SerialDisposable implements IDisposable {
-		constructor();
-
-		isDisposed: boolean;
-
-		dispose(): void;
-		getDisposable(): IDisposable;
-		setDisposable(value: IDisposable): void;
-	}
-
-	export class RefCountDisposable implements IDisposable {
-		constructor(disposable: IDisposable);
-
-		dispose(): void;
-
-		isDisposed: boolean;
-		getDisposable(): IDisposable;
-	}
-
-	export interface IScheduler {
-		now(): number;
-
-		schedule(action: () => void): IDisposable;
-		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
-		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) =>IDisposable): IDisposable;
-
-		scheduleRecursive(action: (action: () =>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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) =>void ) =>void ): IDisposable;
-
-		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
-	}
-
-	// Current Thread IScheduler
-	interface ICurrentThreadScheduler extends IScheduler {
-		scheduleRequired(): boolean;
-	}
-
-	// Notifications
-	export class Notification<T> {
-		accept(observer: IObserver<T>): void;
-		accept<TResult>(onNext: (value: T) => TResult, onError?: (exception: any) => TResult, onCompleted?: () => TResult): TResult;
-		toObservable(scheduler?: IScheduler): Observable<T>;
-		hasValue: boolean;
-		equals(other: Notification<T>): boolean;
-		kind: string;
-		value: T;
-		exception: any;
-
-		static createOnNext<T>(value: T): Notification<T>;
-		static createOnError<T>(exception: any): Notification<T>;
-		static createOnCompleted<T>(): Notification<T>;
-	}
-
-	/**
-	 * Promise A+
-	 */
-	export interface IPromise<T> {
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => IPromise<R>, onRejected?: (reason: any) => R): IPromise<R>;
-		then<R>(onFulfilled: (value: T) => R, onRejected: (reason: any) => IPromise<R>): IPromise<R>;
-		then<R>(onFulfilled?: (value: T) => R, onRejected?: (reason: any) => R): IPromise<R>;
-	}
-
-	// Observer
-	export interface IObserver<T> {
-		onNext(value: T): void;
-		onError(exception: any): void;
-		onCompleted(): void;
-	}
-
-	export interface Observer<T> extends IObserver<T> {
-		toNotifier(): (notification: Notification<T>) => void;
-		asObserver(): Observer<T>;
-	}
-
-	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>;
-	}
-
-	export var Observer: ObserverStatic;
-
-	export interface IObservable<T> {
-		subscribe(observer: Observer<T>): IDisposable;
-		subscribe(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;
-	}
-
-	export interface Observable<T> extends IObservable<T> {
-		forEach(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): IDisposable;	// alias for subscribe
-		toArray(): Observable<T[]>;
-
-		catch(handler: (exception: any) => Observable<T>): Observable<T>;
-		catchException(handler: (exception: any) => Observable<T>): Observable<T>;	// alias for catch
-		catch(handler: (exception: any) => IPromise<T>): Observable<T>;
-		catchException(handler: (exception: any) => IPromise<T>): Observable<T>;	// alias for catch
-		catch(second: Observable<T>): Observable<T>;
-		catchException(second: Observable<T>): Observable<T>;	// alias for catch
-		combineLatest<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		combineLatest<T2, TResult>(second: IPromise<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, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<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, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		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>;
-		concat(...sources: Observable<T>[]): Observable<T>;
-		concat(...sources: IPromise<T>[]): Observable<T>;
-		concat(sources: Observable<T>[]): Observable<T>;
-		concat(sources: IPromise<T>[]): Observable<T>;
-		concatAll(): T;
-		concatObservable(): T;	// alias for concatAll
-		concatMap<T2, R>(selector: (value: T, index: number) => Observable<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;	// alias for selectConcat
-		concatMap<T2, R>(selector: (value: T, index: number) => IPromise<T2>, resultSelector: (value1: T, value2: T2, index: number) => R): Observable<R>;	// alias for selectConcat
-		concatMap<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;	// alias for selectConcat
-		concatMap<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;	// alias for selectConcat
-		concatMap<R>(sequence: Observable<R>): Observable<R>;	// alias for selectConcat
-		merge(maxConcurrent: number): T;
-		merge(other: Observable<T>): Observable<T>;
-		merge(other: IPromise<T>): Observable<T>;
-		mergeAll(): T;
-		mergeObservable(): T;	// alias for mergeAll
-		skipUntil<T2>(other: Observable<T2>): Observable<T>;
-		skipUntil<T2>(other: IPromise<T2>): Observable<T>;
-		switch(): T;
-		switchLatest(): T;	// alias for switch
-		takeUntil<T2>(other: Observable<T2>): Observable<T>;
-		takeUntil<T2>(other: IPromise<T2>): Observable<T>;
-		zip<T2, TResult>(second: Observable<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		zip<T2, TResult>(second: IPromise<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, TResult>(second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		zip<T2, T3, TResult>(second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		zip<T2, T3, TResult>(second: IPromise<T2>, third: IPromise<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, TResult>(second: Observable<T2>, third: Observable<T3>, fourth: IPromise<T4>, resultSelector: (v1: T, v2: T2, v3: T3, v4: T4) => TResult): Observable<TResult>;
-		zip<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>;
-		zip<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>;
-		zip<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>;
-		zip<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>;
-		zip<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>;
-		zip<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>;
-		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<TOther, TResult>(second: Observable<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
-		zip<TOther, TResult>(second: IPromise<TOther>[], resultSelector: (left: T, ...right: TOther[]) => TResult): Observable<TResult>;
-
-		asObservable(): Observable<T>;
-		dematerialize<TOrigin>(): Observable<TOrigin>;
-		distinctUntilChanged(skipParameter: boolean, comparer: (x: T, y: T) => boolean): Observable<T>;
-		distinctUntilChanged<TValue>(keySelector?: (value: T) => TValue, comparer?: (x: TValue, y: TValue) => boolean): Observable<T>;
-		do(observer: Observer<T>): Observable<T>;
-		doAction(observer: Observer<T>): Observable<T>;	// alias for do
-		do(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;
-		doAction(onNext?: (value: T) => void, onError?: (exception: any) => void, onCompleted?: () => void): Observable<T>;	// alias for do
-		finally(action: () => void): Observable<T>;
-		finallyAction(action: () => void): Observable<T>;	// alias for finally
-		ignoreElements(): Observable<T>;
-		materialize(): Observable<Notification<T>>;
-		repeat(repeatCount?: number): Observable<T>;
-		retry(retryCount?: number): Observable<T>;
-		scan<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
-		scan(accumulator: (acc: T, value: T) => T): Observable<T>;
-		skipLast(count: number): Observable<T>;
-		startWith(...values: T[]): Observable<T>;
-		startWith(scheduler: IScheduler, ...values: T[]): Observable<T>;
-		takeLast(count: number, scheduler?: IScheduler): Observable<T>;
-		takeLastBuffer(count: number): Observable<T[]>;
-
-		select<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;
-		map<TResult>(selector: (value: T, index: number, source: Observable<T>) => TResult, thisArg?: any): Observable<TResult>;	// alias for select
-		selectMany<TOther, TResult>(selector: (value: T) => Observable<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
-		selectMany<TOther, TResult>(selector: (value: T) => IPromise<TOther>, resultSelector: (item: T, other: TOther) => TResult): Observable<TResult>;
-		selectMany<TResult>(selector: (value: T) => Observable<TResult>): Observable<TResult>;
-		selectMany<TResult>(selector: (value: T) => IPromise<TResult>): Observable<TResult>;
-		selectMany<TResult>(other: Observable<TResult>): Observable<TResult>;
-		selectMany<TResult>(other: IPromise<TResult>): Observable<TResult>;
-		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
-
-		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>;
-		selectConcat<R>(selector: (value: T, index: number) => Observable<R>): Observable<R>;
-		selectConcat<R>(selector: (value: T, index: number) => IPromise<R>): Observable<R>;
-		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 
-		*  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 
-		*  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>;
-		/**
-		*  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 
-		*  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
-		/**
-		*  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 
-		*  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
-
-		skip(count: number): Observable<T>;
-		skipWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		take(count: number, scheduler?: IScheduler): Observable<T>;
-		takeWhile(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		where(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
-		filter(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>; // alias for where
-
-		/**
-		* Converts an existing observable sequence to an ES6 Compatible Promise
-		* @example
-		* var promise = Rx.Observable.return(42).toPromise(RSVP.Promise);
-		* @param promiseCtor The constructor of the promise.
-		* @returns An ES6 compatible promise with the last value from the observable sequence.
-		*/
-		toPromise<TPromise extends IPromise<T>>(promiseCtor: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): TPromise; }): TPromise;
-		/**
-		* 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();
-		* @param [promiseCtor] The constructor of the promise. If not provided, it looks for it in Rx.config.Promise.
-		* @returns An ES6 compatible promise with the last value from the observable sequence.
-		*/
-		toPromise(promiseCtor?: { new (resolver: (resolvePromise: (value: T) => void, rejectPromise: (reason: any) => void) => void): IPromise<T>; }): IPromise<T>;
-
-		// Experimental Flattening
-
-		/**
-		* Performs a exclusive waiting for the first to finish before subscribing to another observable.
-		* Observables that come in between subscriptions will be dropped on the floor.
-		* Can be applied on `Observable<Observable<R>>` or `Observable<IPromise<R>>`.
-		* @since 2.2.28
-		* @returns A exclusive observable with only the results that happen when subscribed.
-		*/
-		exclusive<R>(): Observable<R>;
-
-		/**
-		* Performs a exclusive map waiting for the first to finish before subscribing to another observable.
-		* Observables that come in between subscriptions will be dropped on the floor.
-		* Can be applied on `Observable<Observable<I>>` or `Observable<IPromise<I>>`.
-		* @since 2.2.28
-		* @param selector Selector to invoke for every item in the current subscription.
-		* @param [thisArg] An optional context to invoke with the selector parameter.
-		* @returns {An exclusive observable with only the results that happen when subscribed.
-		*/
-		exclusiveMap<I, R>(selector: (value: I, index: number, source: Observable<I>) => R, thisArg?: any): Observable<R>;
-	}
-
-	interface ObservableStatic {
-		create<T>(subscribe: (observer: Observer<T>) => IDisposable): Observable<T>;
-		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>;
-		defer<T>(observableFactory: () => IPromise<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>;
-
-		/**
-		*  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.
-		*/
-		fromItreable<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.
-		*/
-		fromItreable<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
-		* @returns The observable sequence whose elements are pulled from the given arguments.
-		*/
-		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. 
-		* @example
-		*  var res = Rx.Observable.ofWithScheduler(Rx.Scheduler.timeout, 1, 2, 3);
-		* @since 2.2.28
-		* @param [scheduler] A scheduler to use for scheduling the arguments.
-		* @returns The observable sequence whose elements are pulled from the given arguments.
-		*/
-		ofWithScheduler<T>(scheduler?: IScheduler, ...values: 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>;
-		/**
-		 * @since 2.2.28
-		 */
-		just<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
-		returnValue<T>(value: T, scheduler?: IScheduler): Observable<T>;	// alias for return
-		throw<T>(exception: Error, scheduler?: IScheduler): Observable<T>;
-		throw<T>(exception: any, scheduler?: IScheduler): Observable<T>;
-		throwException<T>(exception: Error, scheduler?: IScheduler): Observable<T>;	// alias for throw
-		throwException<T>(exception: 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
-		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
-
-		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>;
-		combineLatest<T, T2, TResult>(first: Observable<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		combineLatest<T, T2, TResult>(first: IPromise<T>, second: IPromise<T2>, resultSelector: (v1: T, v2: T2) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: Observable<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: Observable<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: Observable<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<T, T2, T3, TResult>(first: IPromise<T>, second: IPromise<T2>, third: IPromise<T3>, resultSelector: (v1: T, v2: T2, v3: T3) => TResult): Observable<TResult>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<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>;
-		combineLatest<TOther, TResult>(souces: Observable<TOther>[], resultSelector: (...otherValues: TOther[]) => TResult): Observable<TResult>;
-		combineLatest<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>;
-		concat<T>(sources: IPromise<T>[]): Observable<T>;
-		merge<T>(...sources: Observable<T>[]): Observable<T>;
-		merge<T>(...sources: IPromise<T>[]): Observable<T>;
-		merge<T>(sources: Observable<T>[]): Observable<T>;
-		merge<T>(sources: IPromise<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, ...sources: Observable<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, ...sources: IPromise<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, sources: Observable<T>[]): Observable<T>;
-		merge<T>(scheduler: IScheduler, sources: IPromise<T>[]): Observable<T>;
-
-		zip<T1, T2, TResult>(first: Observable<T1>, sources: Observable<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
-		zip<T1, T2, TResult>(first: Observable<T1>, sources: IPromise<T2>[], resultSelector: (item1: T1, ...right: T2[]) => TResult): Observable<TResult>;
-		zip<T1, T2, TResult>(source1: Observable<T1>, source2: Observable<T2>, resultSelector: (item1: T1, item2: T2) => TResult): Observable<TResult>;
-		zip<T1, T2, TResult>(source1: Observable<T1>, source2: IPromise<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, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, resultSelector: (item1: T1, item2: T2, item3: T3) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<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, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: Observable<T2>, source3: IPromise<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: Observable<T3>, source4: IPromise<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: Observable<T4>, resultSelector: (item1: T1, item2: T2, item3: T3, item4: T4) => TResult): Observable<TResult>;
-		zip<T1, T2, T3, T4, TResult>(source1: Observable<T1>, source2: IPromise<T2>, source3: IPromise<T3>, source4: IPromise<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[]>;
-
-		/**
-		* Converts a Promise to an Observable sequence
-		* @param promise An ES6 Compliant promise.
-		* @returns An Observable sequence which wraps the existing promise success and failure.
-		*/
-		fromPromise<T>(promise: IPromise<T>): Observable<T>;
-	}
-
-	export var Observable: ObservableStatic;
-
-	interface ISubject<T> extends Observable<T>, Observer<T>, IDisposable {
-		hasObservers(): boolean;
-	}
-
-    export interface Subject<T> extends ISubject<T> {
-    }
-
-    interface SubjectStatic {
-        new <T>(): Subject<T>;
-		create<T>(observer?: Observer<T>, observable?: Observable<T>): ISubject<T>;
-	}
-
-	export var Subject: SubjectStatic;
-
-	export interface AsyncSubject<T> extends Subject<T> {
-	}
-
-	interface AsyncSubjectStatic {
-		new <T>(): AsyncSubject<T>;
-	}
-
-	export var AsyncSubject: AsyncSubjectStatic;
-}
diff --git a/rx/rx.aggregates.d.ts b/rx/rx.aggregates.d.ts
deleted file mode 100644
index 001d1b993..000000000
--- a/rx/rx.aggregates.d.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-// Type definitions for RxJS-Aggregates v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-
-declare module Rx {
-	export interface Observable<T> {
-		finalValue(): Observable<T>;
-		aggregate(accumulator: (acc: T, value: T) => T): Observable<T>;
-		aggregate<TAcc>(seed: TAcc, accumulator: (acc: TAcc, value: T) => TAcc): Observable<TAcc>;
-
-		reduce(accumulator: (acc: T, value: T) => T): Observable<T>;
-		reduce<TAcc>(accumulator: (acc: TAcc, value: T) => TAcc, seed: TAcc): Observable<TAcc>;		// TS0.9.5: won't work https://typescript.codeplex.com/discussions/471751
-
-		any(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
-		some(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;	// alias for any
-
-		isEmpty(): Observable<boolean>;
-		all(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;
-		every(predicate?: (value: T) => boolean, thisArg?: any): Observable<boolean>;	// alias for all
-		contains(value: T): Observable<boolean>;
-		contains<TOther>(value: TOther, comparer: (value1: T, value2: TOther) => boolean): Observable<boolean>;
-		count(predicate?: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
-		sum(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
-		minBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
-		minBy(keySelector: (item: T) => number): Observable<T>;
-		min(comparer?: (value1: T, value2: T) => number): Observable<T>;
-		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: (value1: TKey, value2: TKey) => number): Observable<T>;
-		maxBy(keySelector: (item: T) => number): Observable<T>;
-		max(comparer?: (value1: T, value2: T) => number): Observable<number>;
-		average(keySelector?: (value: T, index: number, source: Observable<T>) => number, thisArg?: any): Observable<number>;
-
-		sequenceEqual<TOther>(second: Observable<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
-		sequenceEqual<TOther>(second: IPromise<TOther>, comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
-		sequenceEqual(second: Observable<T>): Observable<boolean>;
-		sequenceEqual(second: IPromise<T>): Observable<boolean>;
-		sequenceEqual<TOther>(second: TOther[], comparer: (value1: T, value2: TOther) => number): Observable<boolean>;
-		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>;
-	}
-}
-
-declare module "rx.aggregates" {
-	export = Rx;
-}
\ No newline at end of file
diff --git a/rx/rx.all.ts b/rx/rx.all.ts
deleted file mode 100644
index c546477b8..000000000
--- a/rx/rx.all.ts
+++ /dev/null
@@ -1,20 +0,0 @@
-// Type definitions for RxJS-All v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-/// <reference path="rx.d.ts"/> 
-/// <reference path="rx.aggregates.d.ts"/> 
-/// <reference path="rx.time.d.ts"/> 
-/// <reference path="rx.async.d.ts"/> 
-/// <reference path="rx.binding.d.ts"/> 
-/// <reference path="rx.coincidence.d.ts"/> 
-/// <reference path="rx.experimental.d.ts"/> 
-/// <reference path="rx.joinpatterns.d.ts"/> 
-/// <reference path="rx.virtualtime.d.ts"/> 
-/// <reference path="rx.testing.d.ts"/>
-/// <reference path="rx.backpressure.d.ts" />
-
-declare module "rx.all" {
-	export = Rx;
-}
\ No newline at end of file
diff --git a/rx/rx.async-lite.d.ts b/rx/rx.async-lite.d.ts
deleted file mode 100644
index be13320c2..000000000
--- a/rx/rx.async-lite.d.ts
+++ /dev/null
@@ -1,65 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.async.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-///<reference path="rx-lite.d.ts"/>
-
-declare module Rx {
-    interface ObservableStatic {
-		/**
-		* Invokes the asynchronous function, surfacing the result through an observable sequence.
-		* @param functionAsync Asynchronous function which returns a Promise to run.
-		* @returns An observable sequence exposing the function's result value, or an exception.
-		*/
-		startAsync<T>(functionAsync: () => IPromise<T>): Observable<T>;
-
-		fromCallback: {
-			// with single result callback without selector
-			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any callback with selector
-			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
-			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any callback without selector
-			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-			// with any function with selector
-			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
-			// with any function without selector
-			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
-		};
-
-		fromNodeCallback: {
-			// with single result callback without selector
-			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
-			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
-			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
-			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
-			// with any callback with selector
-			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
-			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
-			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
-			// with any callback without selector
-			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
-			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
-			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
-			// with any function with selector
-			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
-			// with any function without selector
-			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
-		};
-
-		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
-		fromEvent<T>(element: Node, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;
-        fromEventPattern<T>(addHandler: (handler: Function) => void, removeHandler: (handler: Function) => void, selector?: (arguments: any[])=>T): Observable<T>;
-	}
-}
diff --git a/rx/rx.async-tests.ts b/rx/rx.async-tests.ts
deleted file mode 100644
index 9c3bce516..000000000
--- a/rx/rx.async-tests.ts
+++ /dev/null
@@ -1,88 +0,0 @@
-// Tests for RxJS-Async TypeScript definitions
-// Tests by Igor Oleinikov <https://github.com/Igorbek>
-
-/// <reference path="rx.async.d.ts" />
-
-module Rx.Tests.Async {
-
-	var obsNum: Rx.Observable<number>;
-	var obsStr: Rx.Observable<string>;
-	var sch: Rx.IScheduler;
-
-	function start() {
-		obsNum = Rx.Observable.start(()=> 10, sch, obsStr);
-		obsNum = Rx.Observable.start(()=> 10, sch);
-		obsNum = Rx.Observable.start(()=> 10);
-	}
-
-	function toAsync() {
-		obsNum = Rx.Observable.toAsync(()=> 1, sch)();
-		obsNum = Rx.Observable.toAsync((a1: number)=> a1)(1);
-        obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number)=> a1 + a2.toFixed(0))("", 1);
-		obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number, a3: Date)=> a1 + a2.toFixed(0) + a3.toDateString())("", 1, new Date());
-        obsStr = <any>Rx.Observable.toAsync((a1: string, a2: number, a3: Date, a4: boolean)=> a1 + a2.toFixed(0) + a3.toDateString() + (a4 ? 1 : 0))("", 1, new Date(), false);
-	}
-
-	function fromCallback() {
-		// 0 arguments
-		var func0: (cb: (result: number)=> void)=> void;
-		obsNum = Rx.Observable.fromCallback(func0)();
-		obsNum = Rx.Observable.fromCallback(func0, sch)();
-		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr)();
-		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr, (results: number[]) => results[0])();
-
-		// 1 argument
-		var func1: (a: string, cb: (result: number)=> void)=> number;
-		obsNum = Rx.Observable.fromCallback(func1)("");
-		obsNum = Rx.Observable.fromCallback(func1, sch)("");
-		obsNum = Rx.Observable.fromCallback(func1, sch, {})("");
-		obsNum = Rx.Observable.fromCallback(func1, sch, {}, (results: number[]) => results[0])("");
-
-		// 2 arguments
-		var func2: (a: number, b: string, cb: (result: string) => number) => Date;
-		obsStr = Rx.Observable.fromCallback(func2)(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch)(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch, {})(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch, {}, (results: string[]) => results[0])(1, "");
-
-		// 3 arguments
-		var func3: (a: number, b: string, c: boolean, cb: (result: string) => number) => Date;
-		obsStr = Rx.Observable.fromCallback(func3)(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch)(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch, {})(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch, {}, (results: string[]) => results[0])(1, "", true);
-
-		// multiple results
-		var func0m: (cb: (result1: number, result2: number, result3: number) => void) => void;
-		obsNum = Rx.Observable.fromCallback(func0m, sch, obsStr, (results: number[]) => results[0])();
-		var func1m: (a: string, cb: (result1: number, result2: number, result3: number) => void) => void;
-		obsNum = Rx.Observable.fromCallback(func1m, sch, obsStr, (results: number[]) => results[0])("");
-		var func2m: (a: string, b: number, cb: (result1: string, result2: string, result3: string) => void) => void;
-		obsStr = Rx.Observable.fromCallback(func2m, sch, obsStr, (results: string[]) => results[0])("", 10);
-	}
-
-	function toPromise() {
-		var promiseImpl: {
-			new<T>(resolver: (resolvePromise: (value: T)=> void, rejectPromise: (reason: any)=> void)=> void): Rx.IPromise<T>;
-		};
-
-		Rx.config.Promise = promiseImpl;
-
-		var p: IPromise<number> = obsNum.toPromise(promiseImpl);
-
-		p = obsNum.toPromise();
-
-		p = p.then(x=> x);
-		p = p.then(x=> p);
-		p = p.then(undefined, reason=> 10);
-		p = p.then(undefined, reason=> p);
-
-		var ps: IPromise<string> = p.then(undefined, reason=> "error");
-		ps = p.then(x=> "");
-		ps = p.then(x=> ps);
-	}
-
-	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
deleted file mode 100644
index 9370c828b..000000000
--- a/rx/rx.async.d.ts
+++ /dev/null
@@ -1,43 +0,0 @@
-// Type definitions for RxJS-Async v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: zoetrope <https://github.com/zoetrope>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.async-lite.d.ts" />
-
-declare module Rx {
-    interface ObservableStatic {
-		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
-
-        toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
-		toAsync<T1, TResult>(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-	}
-}
-
-declare module "rx.async" {
-	export = Rx;
-}
\ No newline at end of file
diff --git a/rx/rx.backpressure-lite.d.ts b/rx/rx.backpressure-lite.d.ts
deleted file mode 100644
index d1c244195..000000000
--- a/rx/rx.backpressure-lite.d.ts
+++ /dev/null
@@ -1,49 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.backpressure.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-///<reference path="rx-lite.d.ts"/>
-
-declare module Rx {
-	export interface Observable<T> {
-		/**
-		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false.
-		* @example
-		* var pauser = new Rx.Subject();
-		* var source = Rx.Observable.interval(100).pausable(pauser);
-		* @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>;
-
-		/**
-		* Pauses the underlying observable sequence based upon the observable sequence which yields true/false,
-		* and yields the values that were buffered while paused.
-		* @example
-		* var pauser = new Rx.Subject();
-		* var source = Rx.Observable.interval(100).pausableBuffered(pauser);
-		* @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>;
-
-		/**
-		* Attaches a controller to the observable sequence with the ability to queue.
-		* @example
-		* var source = Rx.Observable.interval(100).controlled();
-		* source.request(3); // Reads 3 values
-		*/
-		controlled(enableQueue?: boolean): ControlledObservable<T>;
-	}
-
-	export interface ControlledObservable<T> extends Observable<T> {
-		request(numberOfItems?: number): IDisposable;
-	}
-
-	export interface PausableObservable<T> extends Observable<T> {
-		pause(): void;
-		resume(): void;
-	}
-}
diff --git a/rx/rx.backpressure-tests.ts b/rx/rx.backpressure-tests.ts
deleted file mode 100644
index f036a1dc3..000000000
--- a/rx/rx.backpressure-tests.ts
+++ /dev/null
@@ -1,22 +0,0 @@
-// Tests for RxJS-BackPressure TypeScript definitions
-// Tests by Igor Oleinikov <https://github.com/Igorbek>
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.backpressure.d.ts" />
-
-function testPausable() {
-	var o: Rx.Observable<string>;
-
-	var pauser = new Rx.Subject<boolean>();
-
-	var p = o.pausable(pauser);
-	p = o.pausableBuffered(pauser);
-}
-
-function testControlled() {
-	var o: Rx.Observable<string>;
-	var c = o.controlled();
-
-	var d: Rx.IDisposable = c.request();
-	d = c.request(5);
-}
diff --git a/rx/rx.backpressure.d.ts b/rx/rx.backpressure.d.ts
deleted file mode 100644
index 9c5e8abd5..000000000
--- a/rx/rx.backpressure.d.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// Type definitions for RxJS-BackPressure v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.backpressure-lite.d.ts" />
-
-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
deleted file mode 100644
index f896e260d..000000000
--- a/rx/rx.binding-lite.d.ts
+++ /dev/null
@@ -1,72 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.binding.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-///<reference path="rx-lite.d.ts"/>
-
-declare module Rx {
-	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>(bufferSize?: number, window?: number, scheduler?: IScheduler): ReplaySubject<T>;
-	}
-
-	export var ReplaySubject: ReplaySubjectStatic;
-
-	interface ConnectableObservable<T> extends Observable<T> {
-		connect(): IDisposable;
-		refCount(): Observable<T>;
-    }
-
-    interface ConnectableObservableStatic {
-        new <T>(): ConnectableObservable<T>;
-	}
-
-	export var ConnectableObservable: ConnectableObservableStatic;
-
-	export interface Observable<T> {
-		multicast(subject: Observable<T>): ConnectableObservable<T>;
-		multicast<TResult>(subjectSelector: () => ISubject<T>, selector: (source: ConnectableObservable<T>) => Observable<T>): Observable<T>;
-		publish(): ConnectableObservable<T>;
-		publish<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
-		/**
-		* 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>;
-		publishLast(): ConnectableObservable<T>;
-		publishLast<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>): Observable<TResult>;
-		publishValue(initialValue: T): ConnectableObservable<T>;
-		publishValue<TResult>(selector: (source: ConnectableObservable<T>) => Observable<TResult>, initialValue: T): Observable<TResult>;
-		/**
-		* 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.
-		*/
-		shareValue(initialValue: T): Observable<T>;
-		replay(selector?: boolean, bufferSize?: number, window?: number, scheduler?: IScheduler): ConnectableObservable<T>;	// hack to catch first omitted parameter
-		replay(selector: (source: ConnectableObservable<T>) => Observable<T>, bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
-		shareReplay(bufferSize?: number, window?: number, scheduler?: IScheduler): Observable<T>;
-	}
-}
diff --git a/rx/rx.binding.d.ts b/rx/rx.binding.d.ts
deleted file mode 100644
index b93411a52..000000000
--- a/rx/rx.binding.d.ts
+++ /dev/null
@@ -1,11 +0,0 @@
-// Type definitions for RxJS-Binding v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.binding-lite.d.ts" />
-
-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
deleted file mode 100644
index 801e42168..000000000
--- a/rx/rx.coincidence-lite.d.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-///<reference path="rx-lite.d.ts" />
-
-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. 
-		* 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 
-		* when the source completes.
-		* @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, 
-		*    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
deleted file mode 100644
index 87fa6a55b..000000000
--- a/rx/rx.coincidence.d.ts
+++ /dev/null
@@ -1,36 +0,0 @@
-// Type definitions for RxJS-Coincidence v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.coincidence-lite.d.ts" />
-
-declare module Rx {
-
-	interface Observable<T> {
-		join<TRight, TDurationLeft, TDurationRight, TResult>(
-			right: Observable<TRight>,
-			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
-			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
-			resultSelector: (leftItem: T, rightItem: TRight) => TResult): Observable<TResult>;
-
-		groupJoin<TRight, TDurationLeft, TDurationRight, TResult>(
-			right: Observable<TRight>,
-			leftDurationSelector: (leftItem: T) => Observable<TDurationLeft>,
-			rightDurationSelector: (rightItem: TRight) => Observable<TDurationRight>,
-			resultSelector: (leftItem: T, rightItem: Observable<TRight>) => TResult): Observable<TResult>;
-
-		window<TWindowOpening>(windowOpenings: Observable<TWindowOpening>): Observable<Observable<T>>;
-		window<TWindowClosing>(windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
-		window<TWindowOpening, TWindowClosing>(windowOpenings: Observable<TWindowOpening>, windowClosingSelector: () => Observable<TWindowClosing>): Observable<Observable<T>>;
-
-		buffer<TBufferOpening>(bufferOpenings: Observable<TBufferOpening>): Observable<T[]>;
-		buffer<TBufferClosing>(bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
-		buffer<TBufferOpening, TBufferClosing>(bufferOpenings: Observable<TBufferOpening>, bufferClosingSelector: () => Observable<TBufferClosing>): Observable<T[]>;
-	}
-}
-
-declare module "rx.coincidence" {
-	export = Rx;
-}
\ No newline at end of file
diff --git a/rx/rx.d.ts b/rx/rx.d.ts
deleted file mode 100644
index 1f26a94a9..000000000
--- a/rx/rx.d.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-// Type definitions for RxJS v2.2.28
-// 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
-
-///<reference path="rx-lite.d.ts"/>
-
-declare module Rx {
-	export interface IScheduler {
-		catch(handler: (exception: any) => boolean): IScheduler;
-		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;
-
-		now(): number;
-		catch(handler: (exception: any) => boolean): IScheduler;
-		catchException(handler: (exception: any) => boolean): IScheduler;
-
-		schedule(action: () => void): IDisposable;
-		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-
-		scheduleRecursive(action: (action: () => 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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
-
-		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
-	}
-
-	// Observer
-	export interface Observer<T> {
-		checked(): Observer<any>;
-	}
-
-	interface ObserverStatic {
-		/**
-		* Schedules the invocation of observer methods on the given scheduler.
-		* @param scheduler Scheduler to schedule observer messages on.
-		* @returns Observer whose messages are scheduled on the given scheduler.
-		*/
-		notifyOn<T>(scheduler: IScheduler): Observer<T>;
-	}
-
-	export interface Observable<T> {
-		observeOn(scheduler: IScheduler): Observable<T>;
-		subscribeOn(scheduler: IScheduler): Observable<T>;
-
-		amb(rightSource: Observable<T>): Observable<T>;
-		amb(rightSource: IPromise<T>): Observable<T>;
-		onErrorResumeNext(second: Observable<T>): Observable<T>;
-		onErrorResumeNext(second: IPromise<T>): Observable<T>;
-		bufferWithCount(count: number, skip?: number): Observable<T[]>;
-		windowWithCount(count: number, skip?: number): Observable<Observable<T>>;
-		defaultIfEmpty(defaultValue?: T): Observable<T>;
-		distinct(skipParameter: boolean, valueSerializer: (value: T) => string): Observable<T>;
-		distinct<TKey>(keySelector?: (value: T) => TKey, keySerializer?: (key: TKey) => string): Observable<T>;
-		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, skipElementSelector?: boolean, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
-		groupBy<TKey, TElement>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
-		groupByUntil<TKey, TDuration>(keySelector: (value: T) => TKey, skipElementSelector: boolean, durationSelector: (group: GroupedObservable<TKey, T>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, T>>;
-		groupByUntil<TKey, TElement, TDuration>(keySelector: (value: T) => TKey, elementSelector: (value: T) => TElement, durationSelector: (group: GroupedObservable<TKey, TElement>) => Observable<TDuration>, keySerializer?: (key: TKey) => string): Observable<GroupedObservable<TKey, TElement>>;
-	}
-
-	interface ObservableStatic {
-		using<TSource, TResource extends IDisposable>(resourceFactory: () => TResource, observableFactory: (resource: TResource) => Observable<TSource>): Observable<TSource>;
-		amb<T>(...sources: Observable<T>[]): Observable<T>;
-		amb<T>(...sources: IPromise<T>[]): Observable<T>;
-		amb<T>(sources: Observable<T>[]): Observable<T>;
-		amb<T>(sources: IPromise<T>[]): Observable<T>;
-		onErrorResumeNext<T>(...sources: Observable<T>[]): Observable<T>;
-		onErrorResumeNext<T>(...sources: IPromise<T>[]): Observable<T>;
-		onErrorResumeNext<T>(sources: Observable<T>[]): Observable<T>;
-		onErrorResumeNext<T>(sources: IPromise<T>[]): Observable<T>;
-	}
-
-	interface GroupedObservable<TKey, TElement> extends Observable<TElement> {
-		key: TKey;
-		underlyingObservable: Observable<TElement>;
-	}
-}
-
-declare module "rx" {
-    export = Rx
-}
diff --git a/rx/rx.experimental.d.ts b/rx/rx.experimental.d.ts
deleted file mode 100644
index 60aec86e1..000000000
--- a/rx/rx.experimental.d.ts
+++ /dev/null
@@ -1,321 +0,0 @@
-// Type definitions for RxJS-Experimental v2.2.28
-// Project: https://github.com/Reactive-Extensions/RxJS/
-// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-/// <reference path="rx.d.ts"/>
-
-declare module Rx {
-
-	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.
-		 *
-		 * @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: 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.
-		 *  This operator allows for a fluent style of writing queries that use the same sequence multiple times.
-		 *
-		 * @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: 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): 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.
-		 */
-		expand(selector: (item: T) => Observable<T>, scheduler?: IScheduler): Observable<T>;
-
-		/**
-		 *  Runs two observable sequences in parallel and combines their last elemenets.
-		 *
-		 * @param second Second observable sequence or promise.
-		 * @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: Observable<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
-		forkJoin<TSecond, TResult>(second: IPromise<TSecond>, resultSelector: (left: T, right: TSecond) => TResult): Observable<TResult>;
-
-		/**
-		 * Comonadic bind operator.
-		 * @param selector A transform function to apply to each element.
-		 * @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: Observable<T>, index: number, source: Observable<T>) => TResult, scheduler?: IScheduler): Observable<TResult>;
-	}
-
-	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.
-		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
-		 * @param elseSource The observable sequence or promise 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: Observable<T>, elseSource: Observable<T>): Observable<T>;
-		if<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
-		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
-		if<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.
-		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
-		 * @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: Observable<T>, scheduler?: IScheduler): Observable<T>;
-		if<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
-
-		/**
-		 *  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.
-		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
-		 * @param elseSource The observable sequence or promise 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: Observable<T>, elseSource: Observable<T>): Observable<T>;
-		ifThen<T>(condition: () => boolean, thenSource: Observable<T>, elseSource: IPromise<T>): Observable<T>;
-		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: Observable<T>): Observable<T>;
-		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.
-		 * @param thenSource The observable sequence or promise that will be run if the condition function returns true.
-		 * @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: Observable<T>, scheduler?: IScheduler): Observable<T>;
-		ifThen<T>(condition: () => boolean, thenSource: IPromise<T>, scheduler?: IScheduler): Observable<T>;
-
-		/**
-		 *  Concatenates the observable sequences obtained by running the specified result selector for each element in source.
-		 * 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.  
-		 */
-		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.
-		 * 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.  
-		 */
-		forIn<T, TResult>(sources: T[], resultSelector: (item: T) => Observable<TResult>): Observable<TResult>;
-
-		/**
-		 *  Repeats source as long as condition holds emulating a while loop.
-		 * 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.  
-		 */
-		while<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
-		while<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
-
-		/**
-		 *  Repeats source as long as condition holds emulating a while loop.
-		 * 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.  
-		 */
-		whileDo<T>(condition: () => boolean, source: Observable<T>): Observable<T>;
-		whileDo<T>(condition: () => boolean, source: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-		case<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
-		case<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-		case<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
-		case<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-		switchCase<T>(selector: () => string, sources: { [key: string]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
-		switchCase<T>(selector: () => string, sources: { [key: string]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-
-		/**
-		 *  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.  
-		 */
-		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>;
-		switchCase<T>(selector: () => number, sources: { [key: number]: Observable<T>; }, elseSource: IPromise<T>): Observable<T>;
-		switchCase<T>(selector: () => number, sources: { [key: number]: IPromise<T>; }, elseSource: IPromise<T>): Observable<T>;
-
-		/**
-		 *  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.  
-		 */
-		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.
-		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
-		 */
-		forkJoin<T>(sources: Observable<T>[]): Observable<T[]>;
-		forkJoin<T>(sources: IPromise<T>[]): Observable<T[]>;
-
-		/**
-		 *  Runs all observable sequences in parallel and collect their last elements.
-		 *  
-		 * @example
-		 * res = Rx.Observable.forkJoin(obs1, obs2, ...);
-		 * @param args Source sequences or promises.
-		 * @returns An observable sequence with an array collecting the last elements of all the input sequences.
-		 */
-		forkJoin<T>(...args: Observable<T>[]): Observable<T[]>;
-		forkJoin<T>(...args: IPromise<T>[]): Observable<T[]>;
-	}
-}
-
-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
deleted file mode 100644
index 929c66a6f..000000000
--- a/rx/rx.joinpatterns.d.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-// Type definitions for RxJS-Join v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-
-declare module Rx {
-
-	interface Pattern1<T1> {
-		and<T2>(other: Observable<T2>): Pattern2<T1, T2>;
-		then<TR>(selector: (item1: T1) => TR): Plan<TR>;
-	}
-	interface Pattern2<T1, T2> {
-		and<T3>(other: Observable<T3>): Pattern3<T1, T2, T3>;
-		then<TR>(selector: (item1: T1, item2: T2) => TR): Plan<TR>;
-	}
-	interface Pattern3<T1, T2, T3> {
-		and<T4>(other: Observable<T4>): Pattern4<T1, T2, T3, T4>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3) => TR): Plan<TR>;
-	}
-	interface Pattern4<T1, T2, T3, T4> {
-		and<T5>(other: Observable<T5>): Pattern5<T1, T2, T3, T4, T5>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4) => TR): Plan<TR>;
-	}
-	interface Pattern5<T1, T2, T3, T4, T5> {
-		and<T6>(other: Observable<T6>): Pattern6<T1, T2, T3, T4, T5, T6>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5) => TR): Plan<TR>;
-	}
-	interface Pattern6<T1, T2, T3, T4, T5, T6> {
-		and<T7>(other: Observable<T7>): Pattern7<T1, T2, T3, T4, T5, T6, T7>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6) => TR): Plan<TR>;
-	}
-	interface Pattern7<T1, T2, T3, T4, T5, T6, T7> {
-		and<T8>(other: Observable<T8>): Pattern8<T1, T2, T3, T4, T5, T6, T7, T8>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7) => TR): Plan<TR>;
-	}
-	interface Pattern8<T1, T2, T3, T4, T5, T6, T7, T8> {
-		and<T9>(other: Observable<T9>): Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9>;
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8) => TR): Plan<TR>;
-	}
-	interface Pattern9<T1, T2, T3, T4, T5, T6, T7, T8, T9> {
-		then<TR>(selector: (item1: T1, item2: T2, item3: T3, item4: T4, item5: T5, item6: T6, item7: T7, item8: T8, item9: T9) => TR): Plan<TR>;
-	}
-
-	interface Plan<T> { }
-
-	interface Observable<T> {
-		and<T2>(other: Observable<T2>): Pattern2<T, T2>;
-		then<TR>(selector: (item1: T) => TR): Plan<TR>;
-	}
-
-	interface ObservableStatic {
-		when<TR>(plan: Plan<TR>): Observable<TR>;
-	}
-}
-
-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
deleted file mode 100644
index 046ef527d..000000000
--- a/rx/rx.lite.d.ts
+++ /dev/null
@@ -1,50 +0,0 @@
-// Type definitions for RxJS-Lite v2.2.28
-// 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
-
-///<reference path="rx-lite.d.ts"/>
-///<reference path="rx.async-lite.d.ts" />
-///<reference path="rx.binding-lite.d.ts" />
-///<reference path="rx.time-lite.d.ts" />
-///<reference path="rx.backpressure-lite.d.ts" />
-///<reference path="rx.coincidence-lite.d.ts" />
-
-declare module Rx {
-	export class Scheduler implements IScheduler {
-		constructor(
-			now: () => number,
-			schedule: (state: any, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
-			scheduleRelative: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable,
-			scheduleAbsolute: (state: any, dueTime: number, action: (scheduler: IScheduler, state: any) => IDisposable) => IDisposable);
-
-		static normalize(timeSpan: number): number;
-
-		static immediate: IScheduler;
-		static currentThread: ICurrentThreadScheduler;
-		static timeout: IScheduler;
-
-		now(): number;
-
-		schedule(action: () => void): IDisposable;
-		scheduleWithState<TState>(state: TState, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithAbsolute(dueTime: number, action: () => void): IDisposable;
-		scheduleWithAbsoluteAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleWithRelative(dueTime: number, action: () => void): IDisposable;
-		scheduleWithRelativeAndState<TState>(state: TState, dueTime: number, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-
-		scheduleRecursive(action: (action: () => 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<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<TState>(state: TState, dueTime: number, action: (state: TState, action: (state: TState, dueTime: number) => void) => void): IDisposable;
-
-		schedulePeriodic(period: number, action: () => void): IDisposable;
-		schedulePeriodicWithState<TState>(state: TState, period: number, action: (state: TState) => TState): IDisposable;
-	}
-}
-
-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
deleted file mode 100644
index 0adc83e50..000000000
--- a/rx/rx.testing.d.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// Type definitions for RxJS-Testing v2.2.28
-// Project: https://github.com/Reactive-Extensions/RxJS/
-// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.virtualtime.d.ts" />
-
-declare module Rx {
-	export class TestScheduler extends VirtualTimeScheduler<number, number> {
-		constructor();
-
-		createColdObservable<T>(...records: Recorded[]): Observable<T>;
-		createHotObservable<T>(...records: Recorded[]): Observable<T>;
-		createObserver<T>(): MockObserver<T>;
-
-		startWithTiming<T>(create: () => Observable<T>, createdAt: number, subscribedAt: number, disposedAt: number): MockObserver<T>;
-		startWithDispose<T>(create: () => Observable<T>, disposedAt: number): MockObserver<T>;
-		startWithCreate<T>(create: () => Observable<T>): MockObserver<T>;
-	}
-
-	export class Recorded {
-		constructor(time: number, value: any, equalityComparer?: (x: any, y: any) => boolean);
-		equals(other: Recorded): boolean;
-		toString(): string;
-		time: number;
-		value: any;
-	}
-
-	export var ReactiveTest: {
-		created: number;
-		subscribed: number;
-		disposed: number;
-
-		onNext(ticks: number, value: any): Recorded;
-		onNext(ticks: number, predicate: (value: any) => boolean): Recorded;
-		onError(ticks: number, exception: any): Recorded;
-		onError(ticks: number, predicate: (exception: any) => boolean): Recorded;
-		onCompleted(ticks: number): Recorded;
-
-		subscribe(subscribeAt: number, unsubscribeAt?: number): Subscription;
-	};
-
-	export class Subscription {
-		constructor(subscribeAt: number, unsubscribeAt?: number);
-		equals(other: Subscription): boolean;
-	}
-
-	export interface MockObserver<T> extends Observer<T> {
-		messages: Recorded[];
-	}
-
-	interface MockObserverStatic extends ObserverStatic {
-		new <T>(scheduler: IScheduler): MockObserver<T>;
-	}
-
-	export var MockObserver: MockObserverStatic;
-}
-
-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
deleted file mode 100644
index a5b102827..000000000
--- a/rx/rx.time-lite.d.ts
+++ /dev/null
@@ -1,62 +0,0 @@
-// DefinitelyTyped: partial
-
-// This file contains common part of defintions for rx.time.d.ts and rx.lite.d.ts
-// Do not include the file separately.
-
-///<reference path="rx-lite.d.ts" />
-
-declare module Rx {
-	export interface TimeInterval<T> {
-		value: T;
-		interval: number;
-	}
-
-	export interface Timestamp<T> {
-		value: T;
-		timestamp: number;
-	}
-
-	export interface Observable<T> {
-		delay(dueTime: number, scheduler?: IScheduler): Observable<T>;
-		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>;
-
-		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 {
-		interval(period: number, scheduler?: IScheduler): Observable<number>;
-		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
deleted file mode 100644
index 6efd7d9cf..000000000
--- a/rx/rx.time.d.ts
+++ /dev/null
@@ -1,35 +0,0 @@
-// Type definitions for RxJS-Time v2.2.28
-// Project: http://rx.codeplex.com/
-// Definitions by: Carl de Billy <http://carl.debilly.net/>, Igor Oleinikov <https://github.com/Igorbek>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-///<reference path="rx.d.ts" />
-///<reference path="rx.time-lite.d.ts" />
-
-declare module Rx {
-	export interface 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>>;
-		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[]>;
-	}
-
-	interface ObservableStatic {
-		timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
-		timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
-
-		generateWithAbsoluteTime<TState, TResult>(
-			initialState: TState,
-			condition: (state: TState) => boolean,
-			iterate: (state: TState) => TState,
-			resultSelector: (state: TState) => TResult,
-			timeSelector: (state: TState) => Date,
-			scheduler?: IScheduler): Observable<TResult>;
-	}
-}
-
-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
deleted file mode 100644
index 50a1bb39b..000000000
--- a/rx/rx.virtualtime.d.ts
+++ /dev/null
@@ -1,39 +0,0 @@
-// Type definitions for RxJS-VirtualTime v2.2.28
-// 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
-
-///<reference path="rx.d.ts" />
-
-declare module Rx {
-    // Virtual IScheduler
-	export /*abstract*/ class VirtualTimeScheduler<TAbsolute, TRelative> extends Scheduler {
-		constructor(initialClock: TAbsolute, comparer: (first: TAbsolute, second: TAbsolute) => number);
-
-		advanceBy(time: TRelative): void;
-		advanceTo(time: TAbsolute): void;
-		scheduleAbsolute(dueTime: TAbsolute, action: () => void): IDisposable;
-		scheduleAbsoluteWithState<TState>(state: TState, dueTime: TAbsolute, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		scheduleRelative(dueTime: TRelative, action: () => void): IDisposable;
-		scheduleRelativeWithState<TState>(state: TState, dueTime: TRelative, action: (scheduler: IScheduler, state: TState) => IDisposable): IDisposable;
-		sleep(time: TRelative): void;
-		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);
-	}
-}
-
-declare module "rx.virtualtime" {
-	export = Rx;
-}
\ No newline at end of file

From 77615ebcf03c7da283edd182dc14704bc5f8385f Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 10:03:38 -0700
Subject: [PATCH 04/11] Added few helpers functions.

---
 rx-lite.d.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/rx-lite.d.ts b/rx-lite.d.ts
index c7a148137..eea3c55ce 100644
--- a/rx-lite.d.ts
+++ b/rx-lite.d.ts
@@ -49,6 +49,8 @@ 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;

From 68b8e0481ff91f731f75e4f48ac3d81226a1272a Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 12:10:45 -0700
Subject: [PATCH 05/11] Added ObservableStatic.from definition.

---
 rx-lite.d.ts | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/rx-lite.d.ts b/rx-lite.d.ts
index eea3c55ce..f33193af2 100644
--- a/rx-lite.d.ts
+++ b/rx-lite.d.ts
@@ -396,6 +396,50 @@ declare module Rx {
 		defer<T>(observableFactory: () => Observable<T>): Observable<T>;
 		defer<T>(observableFactory: () => IPromise<T>): Observable<T>;
 		empty<T>(scheduler?: IScheduler): Observable<T>;
+
+		/**
+		* This method creates a new Observable sequence from an array object.
+		* @param array An array-like or iterable object to convert to an Observable sequence.
+		* @param mapFn Map function to call on every element of the array.
+		* @param [thisArg] The context to use calling the mapFn if provided.
+		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
+		*/
+		from<T, TResult>(array: T[], mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler);
+		/**
+		* This method creates a new Observable sequence from an array object.
+		* @param array An array-like or iterable object to convert to an Observable sequence.
+		* @param [mapFn] Map function to call on every element of the array.
+		* @param [thisArg] The context to use calling the mapFn if provided.
+		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
+		*/
+		from<T>(array: T[], mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+
+		/**
+		* This method creates a new Observable sequence from an array-like object.
+		* @param array An array-like or iterable object to convert to an Observable sequence.
+		* @param mapFn Map function to call on every element of the array.
+		* @param [thisArg] The context to use calling the mapFn if provided.
+		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
+		*/
+		from<T, TResult>(array: { length: number; [index: number]: T; }, mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler);
+		/**
+		* This method creates a new Observable sequence from an array-like object.
+		* @param array An array-like or iterable object to convert to an Observable sequence.
+		* @param [mapFn] Map function to call on every element of the array.
+		* @param [thisArg] The context to use calling the mapFn if provided.
+		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
+		*/
+		from<T>(array: { length: number; [index: number]: T; }, mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+
+		/**
+		* This method creates a new Observable sequence from an array-like or iterable object.
+		* @param array An array-like or iterable object to convert to an Observable sequence.
+		* @param [mapFn] Map function to call on every element of the array.
+		* @param [thisArg] The context to use calling the mapFn if provided.
+		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
+		*/
+		from<T>(iterable: any, mapFn?: (value: any, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+
 		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
 		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;
 

From 0f4537ae1cc2718cf670ef186dd71d17ab9e05b5 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 12:50:51 -0700
Subject: [PATCH 06/11] Removed scheduler parameter from fromCallback and
 fromNodeCallback.

---
 rx.async-lite.d.ts | 56 +++++++++++++++++++++++-----------------------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/rx.async-lite.d.ts b/rx.async-lite.d.ts
index be13320c2..77dc23b57 100644
--- a/rx.async-lite.d.ts
+++ b/rx.async-lite.d.ts
@@ -16,46 +16,46 @@ declare module Rx {
 
 		fromCallback: {
 			// with single result callback without selector
-			<TResult>(func: (callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			<TResult>(func: (callback: (result: TResult) => any) => any, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: (result: TResult) => any) => any, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (result: TResult) => any) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
 			// with any callback with selector
-			<TCallbackResult, TResult>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
-			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			<TCallbackResult, TResult>(func: (callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): () => Observable<TResult>;
+			<T1, TCallbackResult, TResult>(func: (arg1: T1, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TCallbackResult, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (args: TCallbackResult[]) => TResult): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
 			// with any callback without selector
-			<TResult>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-			<T1, TResult>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+			<TResult>(func: (callback: Function) => any, context?: any): () => Observable<TResult>;
+			<T1, TResult>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TResult>;
+			<T1, T2, TResult>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
+			<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
 			// with any function with selector
-			<TCallbackResult, TResult>(func: Function, scheduler: IScheduler, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
+			<TCallbackResult, TResult>(func: Function, context: any, selector: (args: TCallbackResult[]) => TResult): (...args: any[]) => Observable<TResult>;
 			// with any function without selector
-			<TResult>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<TResult>;
+			<TResult>(func: Function, context?: any): (...args: any[]) => Observable<TResult>;
 		};
 
 		fromNodeCallback: {
 			// with single result callback without selector
-			<T>(func: (callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): () => Observable<T>;
-			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<T>;
-			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
-			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
+			<T>(func: (callback: (err: any, result: T) => any) => any, context?: any): () => Observable<T>;
+			<T1, T>(func: (arg1: T1, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1) => Observable<T>;
+			<T1, T2, T>(func: (arg1: T1, arg2: T2, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1, arg2: T2) => Observable<T>;
+			<T1, T2, T3, T>(func: (arg1: T1, arg2: T2, arg3: T3, callback: (err: any, result: T) => any) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<T>;
 			// with any callback with selector
-			<TC, TR>(func: (callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
-			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
-			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler: IScheduler, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			<TC, TR>(func: (callback: Function) => any, context: any, selector: (results: TC[]) => TR): () => Observable<TR>;
+			<T1, TC, TR>(func: (arg1: T1, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1) => Observable<TR>;
+			<T1, T2, TC, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TC, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context: any, selector: (results: TC[]) => TR): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
 			// with any callback without selector
-			<TR>(func: (callback: Function) => any, scheduler?: IScheduler, context?: any): () => Observable<TR>;
-			<T1, TR>(func: (arg1: T1, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TR>;
-			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
-			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
+			<TR>(func: (callback: Function) => any, context?: any): () => Observable<TR>;
+			<T1, TR>(func: (arg1: T1, callback: Function) => any, context?: any): (arg1: T1) => Observable<TR>;
+			<T1, T2, TR>(func: (arg1: T1, arg2: T2, callback: Function) => any, context?: any): (arg1: T1, arg2: T2) => Observable<TR>;
+			<T1, T2, T3, TR>(func: (arg1: T1, arg2: T2, arg3: T3, callback: Function) => any, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TR>;
 			// with any function with selector
-			<TC, T>(func: Function, scheduler: IScheduler, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
+			<TC, T>(func: Function, context: any, selector: (results: TC[]) => T): (...args: any[]) => Observable<T>;
 			// with any function without selector
-			<T>(func: Function, scheduler?: IScheduler, context?: any): (...args: any[]) => Observable<T>;
+			<T>(func: Function, context?: any): (...args: any[]) => Observable<T>;
 		};
 
 		fromEvent<T>(element: NodeList, eventName: string, selector?: (arguments: any[]) => T): Observable<T>;

From 4c9e9782a7618445da97362529608d38716cba60 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 12:57:09 -0700
Subject: [PATCH 07/11] Exchanged parameters scheduler and context in
 ObservableStatic.start.

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

diff --git a/rx.async.d.ts b/rx.async.d.ts
index 9370c828b..fd85bcd7d 100644
--- a/rx.async.d.ts
+++ b/rx.async.d.ts
@@ -8,7 +8,7 @@
 
 declare module Rx {
     interface ObservableStatic {
-		start<T>(func: () => T, scheduler?: IScheduler, context?: any): Observable<T>;
+		start<T>(func: () => T, context?: any, scheduler?: IScheduler): Observable<T>;
 
         toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
 		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;

From 60a7a1e19bbe21efa50011c93cee170154e3faf9 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 13:00:08 -0700
Subject: [PATCH 08/11] Exchanged parameters scheduler and context in
 ObservableStatic.toAsync.

---
 rx.async.d.ts | 50 +++++++++++++++++++++++++-------------------------
 1 file changed, 25 insertions(+), 25 deletions(-)

diff --git a/rx.async.d.ts b/rx.async.d.ts
index fd85bcd7d..783f31d52 100644
--- a/rx.async.d.ts
+++ b/rx.async.d.ts
@@ -10,31 +10,31 @@ declare module Rx {
     interface ObservableStatic {
 		start<T>(func: () => T, context?: any, scheduler?: IScheduler): Observable<T>;
 
-        toAsync<TResult>(func: () => TResult, scheduler?: IScheduler, context?: any): () => Observable<TResult>;
-		toAsync<T1, TResult>(func: (arg1: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1) => Observable<TResult>;
-		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1) => Observable<TResult>;
-		toAsync<T1, TResult>(func: (...args: T1[]) => TResult, scheduler?: IScheduler, context?: any): (...args: T1[]) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, ...args: T2[]) => Observable<TResult>;
-		toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
-		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, scheduler?: IScheduler, context?: any): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+        toAsync<TResult>(func: () => TResult, context?: any, scheduler?: IScheduler): () => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1: T1) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (arg1?: T1) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1) => Observable<TResult>;
+		toAsync<T1, TResult>(func: (...args: T1[]) => TResult, context?: any, scheduler?: IScheduler): (...args: T1[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2: T2) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, arg2?: T2) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, arg2?: T2) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, arg2?: T2) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1: T1, ...args: T2[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, TResult>(func: (arg1?: T1, ...args: T2[]) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, ...args: T2[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3: T3) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, arg2?: T2, arg3?: T3) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2: T2, ...args: T3[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1: T1, arg2?: T2, ...args: T3[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, TResult>(func: (arg1?: T1, arg2?: T2, ...args: T3[]) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, arg2?: T2, ...args: T3[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3: T3, arg4: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, arg2?: T2, arg3?: T3, arg4?: T4) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, context?: any, scheduler?: IScheduler): (arg1: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
+		toAsync<T1, T2, T3, T4, TResult>(func: (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => TResult, context?: any, scheduler?: IScheduler): (arg1?: T1, arg2?: T2, arg3?: T3, ...args: T4[]) => Observable<TResult>;
 	}
 }
 

From f3910a041c316523ef5e4fedb37f771c4f77a1dd Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 13:19:13 -0700
Subject: [PATCH 09/11] Added return type annotation in ObservableStatic.from.

---
 rx-lite.d.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/rx-lite.d.ts b/rx-lite.d.ts
index f33193af2..4b5acb81d 100644
--- a/rx-lite.d.ts
+++ b/rx-lite.d.ts
@@ -404,7 +404,7 @@ declare module Rx {
 		* @param [thisArg] The context to use calling the mapFn if provided.
 		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
 		*/
-		from<T, TResult>(array: T[], mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler);
+		from<T, TResult>(array: T[], mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
 		/**
 		* This method creates a new Observable sequence from an array object.
 		* @param array An array-like or iterable object to convert to an Observable sequence.
@@ -412,7 +412,7 @@ declare module Rx {
 		* @param [thisArg] The context to use calling the mapFn if provided.
 		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
 		*/
-		from<T>(array: T[], mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+		from<T>(array: T[], mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		* This method creates a new Observable sequence from an array-like object.
@@ -421,7 +421,7 @@ declare module Rx {
 		* @param [thisArg] The context to use calling the mapFn if provided.
 		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
 		*/
-		from<T, TResult>(array: { length: number; [index: number]: T; }, mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler);
+		from<T, TResult>(array: { length: number;[index: number]: T; }, mapFn: (value: T, index: number) => TResult, thisArg?: any, scheduler?: IScheduler): Observable<TResult>;
 		/**
 		* This method creates a new Observable sequence from an array-like object.
 		* @param array An array-like or iterable object to convert to an Observable sequence.
@@ -429,7 +429,7 @@ declare module Rx {
 		* @param [thisArg] The context to use calling the mapFn if provided.
 		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
 		*/
-		from<T>(array: { length: number; [index: number]: T; }, mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+		from<T>(array: { length: number;[index: number]: T; }, mapFn?: (value: T, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
 
 		/**
 		* This method creates a new Observable sequence from an array-like or iterable object.
@@ -438,7 +438,7 @@ declare module Rx {
 		* @param [thisArg] The context to use calling the mapFn if provided.
 		* @param [scheduler] Optional scheduler to use for scheduling.  If not provided, defaults to Scheduler.currentThread.
 		*/
-		from<T>(iterable: any, mapFn?: (value: any, index: number) => T, thisArg?: any, scheduler?: IScheduler);
+		from<T>(iterable: any, mapFn?: (value: any, index: number) => T, thisArg?: any, scheduler?: IScheduler): Observable<T>;
 
 		fromArray<T>(array: T[], scheduler?: IScheduler): Observable<T>;
 		fromArray<T>(array: { length: number;[index: number]: T; }, scheduler?: IScheduler): Observable<T>;

From 8da4768d8f99c40d5c80fa818720f4fe7e5846ff Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 22 Jul 2014 14:41:11 -0700
Subject: [PATCH 10/11] Fixed rx.async-tests.ts.

---
 rx.async-tests.ts | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/rx.async-tests.ts b/rx.async-tests.ts
index 9c3bce516..4f8c102c4 100644
--- a/rx.async-tests.ts
+++ b/rx.async-tests.ts
@@ -10,8 +10,8 @@ module Rx.Tests.Async {
 	var sch: Rx.IScheduler;
 
 	function start() {
-		obsNum = Rx.Observable.start(()=> 10, sch, obsStr);
-		obsNum = Rx.Observable.start(()=> 10, sch);
+		obsNum = Rx.Observable.start(()=> 10, obsStr, sch);
+		obsNum = Rx.Observable.start(() => 10, obsStr);
 		obsNum = Rx.Observable.start(()=> 10);
 	}
 
@@ -27,38 +27,34 @@ module Rx.Tests.Async {
 		// 0 arguments
 		var func0: (cb: (result: number)=> void)=> void;
 		obsNum = Rx.Observable.fromCallback(func0)();
-		obsNum = Rx.Observable.fromCallback(func0, sch)();
-		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr)();
-		obsNum = Rx.Observable.fromCallback(func0, sch, obsStr, (results: number[]) => results[0])();
+		obsNum = Rx.Observable.fromCallback(func0, obsStr)();
+		obsNum = Rx.Observable.fromCallback(func0, obsStr, (results: number[]) => results[0])();
 
 		// 1 argument
 		var func1: (a: string, cb: (result: number)=> void)=> number;
 		obsNum = Rx.Observable.fromCallback(func1)("");
-		obsNum = Rx.Observable.fromCallback(func1, sch)("");
-		obsNum = Rx.Observable.fromCallback(func1, sch, {})("");
-		obsNum = Rx.Observable.fromCallback(func1, sch, {}, (results: number[]) => results[0])("");
+		obsNum = Rx.Observable.fromCallback(func1, {})("");
+		obsNum = Rx.Observable.fromCallback(func1, {}, (results: number[]) => results[0])("");
 
 		// 2 arguments
 		var func2: (a: number, b: string, cb: (result: string) => number) => Date;
 		obsStr = Rx.Observable.fromCallback(func2)(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch)(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch, {})(1, "");
-		obsStr = Rx.Observable.fromCallback(func2, sch, {}, (results: string[]) => results[0])(1, "");
+		obsStr = Rx.Observable.fromCallback(func2, {})(1, "");
+		obsStr = Rx.Observable.fromCallback(func2, {}, (results: string[]) => results[0])(1, "");
 
 		// 3 arguments
 		var func3: (a: number, b: string, c: boolean, cb: (result: string) => number) => Date;
 		obsStr = Rx.Observable.fromCallback(func3)(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch)(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch, {})(1, "", true);
-		obsStr = Rx.Observable.fromCallback(func3, sch, {}, (results: string[]) => results[0])(1, "", true);
+		obsStr = Rx.Observable.fromCallback(func3, {})(1, "", true);
+		obsStr = Rx.Observable.fromCallback(func3, {}, (results: string[]) => results[0])(1, "", true);
 
 		// multiple results
 		var func0m: (cb: (result1: number, result2: number, result3: number) => void) => void;
-		obsNum = Rx.Observable.fromCallback(func0m, sch, obsStr, (results: number[]) => results[0])();
+		obsNum = Rx.Observable.fromCallback(func0m, obsStr, (results: number[]) => results[0])();
 		var func1m: (a: string, cb: (result1: number, result2: number, result3: number) => void) => void;
-		obsNum = Rx.Observable.fromCallback(func1m, sch, obsStr, (results: number[]) => results[0])("");
+		obsNum = Rx.Observable.fromCallback(func1m, obsStr, (results: number[]) => results[0])("");
 		var func2m: (a: string, b: number, cb: (result1: string, result2: string, result3: string) => void) => void;
-		obsStr = Rx.Observable.fromCallback(func2m, sch, obsStr, (results: string[]) => results[0])("", 10);
+		obsStr = Rx.Observable.fromCallback(func2m, obsStr, (results: string[]) => results[0])("", 10);
 	}
 
 	function toPromise() {

From adec547b22bd74c934286d45d4432d19d5930307 Mon Sep 17 00:00:00 2001
From: Igor Oleinikov <igor@oleinikov.ru>
Date: Tue, 30 Sep 2014 15:54:40 -0700
Subject: [PATCH 11/11] Made `scheduler` parameter of `Observable.timer`
 optional (fixes Reactive-Extensions/RxJS#282).

---
 rx.time-lite.d.ts | 4 ++--
 rx.time.d.ts      | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/rx.time-lite.d.ts b/rx.time-lite.d.ts
index a5b102827..7a7d8f46f 100644
--- a/rx.time-lite.d.ts
+++ b/rx.time-lite.d.ts
@@ -49,8 +49,8 @@ declare module Rx {
 	interface ObservableStatic {
 		interval(period: number, scheduler?: IScheduler): Observable<number>;
 		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>;
+		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,
diff --git a/rx.time.d.ts b/rx.time.d.ts
index 6efd7d9cf..2cdb1d56a 100644
--- a/rx.time.d.ts
+++ b/rx.time.d.ts
@@ -17,8 +17,8 @@ declare module Rx {
 	}
 
 	interface ObservableStatic {
-		timer(dueTime: Date, period: number, scheduler: IScheduler): Observable<number>;
-		timer(dueTime: Date, scheduler: IScheduler): Observable<number>;
+		timer(dueTime: Date, period: number, scheduler?: IScheduler): Observable<number>;
+		timer(dueTime: Date, scheduler?: IScheduler): Observable<number>;
 
 		generateWithAbsoluteTime<TState, TResult>(
 			initialState: TState,