diff --git a/ix.js/ix-tests.ts b/ix.js/ix-tests.ts
new file mode 100644
index 000000000..6953621ca
--- /dev/null
+++ b/ix.js/ix-tests.ts
@@ -0,0 +1,116 @@
+///<reference path="ix.d.ts"/>
+
+var ec_ns = (a: number, b: string) => a.toString() == b;	//equality comparer on number,string
+var ec_ss = (a: string, b: string) => a == b;				//equality comparer on string,string
+var ec_nn = (a: number, b: number) => a === b;				//equality comparer on number,number
+var c_nn = (a: number, b: number) => a - b;					//comparer on number,number
+
+// static
+
+Ix.Enumerable.throw(new Error("error"));
+Ix.Enumerable.throwException(new Error("error"));
+
+var ax = Ix.Enumerable.generate(-100, a => a < 100, a=> a + 10, a=> a * 2);
+
+Ix.Enumerable.defer(() => ax);
+
+Ix.Enumerable.using(() => ax.getEnumerator(), e => Ix.Enumerable.return(e.getCurrent()));
+
+Ix.Enumerable.catch(ax, ax, ax);
+Ix.Enumerable.catchException(ax, ax, ax);
+Ix.Enumerable.catch<string>();
+Ix.Enumerable.catchException<string>();
+
+Ix.Enumerable.onErrorResumeNext(ax, ax, ax);
+Ix.Enumerable.onErrorResumeNext<string>();
+
+Ix.Enumerable.while(x => x.count() > 0, ax);
+Ix.Enumerable.whileDo(x => x.count() > 0, ax);
+
+Ix.Enumerable.if(() => true, ax, ax);
+Ix.Enumerable.ifThen(() => true, ax, ax);
+Ix.Enumerable.if(() => true, ax);
+Ix.Enumerable.ifThen(() => true, ax);
+
+Ix.Enumerable.doWhile(ax, x => x.count() > 0);
+
+Ix.Enumerable.case(() => 42, { 42: ax }, ax);
+Ix.Enumerable.switchCase(() => 42, { 42: ax }, ax);
+Ix.Enumerable.case(() => 42, { 42: ax });
+Ix.Enumerable.switchCase(() => 42, { 42: ax });
+Ix.Enumerable.case(() => "42", { "42": ax }, ax);
+Ix.Enumerable.switchCase(() => "42", { "42": ax }, ax);
+Ix.Enumerable.case(() => "42", { "42": ax });
+Ix.Enumerable.switchCase(() => "42", { "42": ax });
+
+Ix.Enumerable.for(ax, a => ax);
+Ix.Enumerable.forIn(ax, a => ax);
+
+// instance
+
+var bx: Ix.Enumerable<string>;
+
+ax.isEmpty();
+
+bx.minBy(b => b.length, c_nn);
+bx.minBy(b => b.length);
+bx.maxBy(b => b.length, c_nn);
+bx.maxBy(b => b.length);
+
+ax.share(ax => bx);
+ax.share();
+
+ax.publish(ax => bx);
+ax.publish();
+
+ax.memoize();
+
+ax.do({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
+ax.do(a => console.log(a), err => console.log(err), () => console.log("completed"));
+ax.do(a => console.log(a), err => console.log(err));
+ax.do((a: number) => console.log(a));
+ax.doAction({ onNext: (a: number) => console.log(a), onError: err => console.log(err), onCompleted: () => console.log("completed") });
+ax.doAction(a => console.log(a), err => console.log(err), () => console.log("completed"));
+ax.doAction(a => console.log(a), err => console.log(err));
+ax.doAction((a: number) => console.log(a));
+
+ax.bufferWithCount(10, 20);
+ax.bufferWithCount(10);
+
+ax.ignoreElements();
+
+bx.distinctBy(b => b.length, ec_nn);
+bx.distinctBy(b => b.length);
+
+bx.distinctUntilChanged(b => b.length, ec_nn);
+bx.distinctUntilChanged(b => b.length);
+bx.distinctUntilChanged();
+bx.distinctUntilChanged(false, ec_ss);
+
+ax.expand(a => ax);
+
+ax.startWith(10, 20);
+
+ax.scan(0, (acc, a) => acc + a);
+ax.scan((acc, a) => acc + a);
+
+ax.takeLast(10);
+ax.skipLast(10);
+
+ax.repeat(10);
+ax.repeat();
+
+ax.catch(ax, ax, ax);
+ax.catchException(ax, ax, ax);
+ax.catch(ax);
+ax.catchException(ax);
+ax.catch(err => ax);
+ax.catchException(err => ax);
+
+ax.finally(() => { });
+ax.finallyDo(() => { });
+
+ax.onErrorResumeNext(ax);
+
+ax.retry(10);
+ax.retry();
diff --git a/ix.js/ix.d.ts b/ix.js/ix.d.ts
new file mode 100644
index 000000000..614a950fb
--- /dev/null
+++ b/ix.js/ix.d.ts
@@ -0,0 +1,112 @@
+// Type definitions for IxJS 1.0.6 / ix.js
+// Project: https://github.com/Reactive-Extensions/IxJS
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+
+///<reference path="l2o.d.ts"/>
+
+declare module Ix {
+
+	export interface Observer<T> {
+		onNext? (value: T): void;
+		onError? (error: Error): void;
+		onCompleted? (): void;
+	}
+
+	export interface Enumerable<T> {
+		isEmpty(): boolean;
+
+		minBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
+		minBy(keySelector: (item: T) => number): Enumerable<T>;
+		maxBy<TKey>(keySelector: (item: T) => TKey, comparer: Comparer<TKey, TKey>): Enumerable<T>;
+		maxBy(keySelector: (item: T) => number): Enumerable<T>;
+
+		share<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
+		share(): Enumerable<T>;
+
+		publish<TResult>(selector: (source: Enumerable<T>) => Enumerable<TResult>): Enumerable<TResult>;
+		publish(): Enumerable<T>;
+
+		memoize(): Enumerable<T>;
+
+		do(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
+		doAction(onNext: (value: T) => void, onError?: (error: Error) => void, onCompleted?: () => void): Enumerable<T>;
+		do(onbserver: Observer<T>): Enumerable<T>;
+		doAction(onbserver: Observer<T>): Enumerable<T>;
+
+		bufferWithCount(count: number, skip?: number): Enumerable<T>;
+
+		ignoreElements(): Enumerable<T>;
+
+		distinctBy<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
+
+		distinctUntilChanged<TKey>(keySelector: (item: T) => TKey, comparer?: EqualityComparer<TKey, TKey>): Enumerable<T>;
+		distinctUntilChanged(): Enumerable<T>;
+		// if need to set comparer without keySelector
+		distinctUntilChanged(_: boolean, comparer: EqualityComparer<T, T>): Enumerable<T>;
+
+		expand(selector: (item: T) => Enumerable<T>): Enumerable<T>;
+
+		startWith(...values: T[]): Enumerable<T>;
+
+		scan<TSeed, TAccumulator>(seed: TSeed, accumulate: (acc: TAccumulator, item: T) => TAccumulator): Enumerable<TAccumulator>;
+		scan(accumulate: (acc: T, item: T) => T): Enumerable<T>;
+
+		takeLast(count: number): Enumerable<T>;
+		skipLast(count: number): Enumerable<T>;
+
+		repeat(count?: number): Enumerable<T>;
+
+		catch(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
+		catchException(handler: (error: Error) => Enumerable<T>): Enumerable<T>;
+		catch(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
+		catchException(second: Enumerable<T>, ...other: Enumerable<T>[]): Enumerable<T>;
+
+		// todo: Enumerable<Enumerable<T>>.catch(): Enumerable<T>
+		//catch<TInner, T extends Enumerable<TInner>>(): Enumerable<TInner>;
+
+		finally(finallyAction: () => void): Enumerable<T>;
+		finallyDo(finallyAction: () => void): Enumerable<T>;
+
+		onErrorResumeNext(second: Enumerable<T>): Enumerable<T>;
+
+		retry(retryCount?: number): Enumerable<T>;
+	}
+
+	export interface EnumerableStatic {
+		throw<T>(error: Error): Enumerable<T>;
+		throwException<T>(error: Error): Enumerable<T>;
+
+		defer<T>(enumerableFactory: () => Enumerable<T>): Enumerable<T>;
+
+		generate<TState, TResult>(
+			initialState: TState,
+			condition: Predicate<TState>,
+			iterate: (state: TState) => TState,
+			resultSelector: (state: TState) => TResult): Enumerable<TResult>;
+
+		using<TResource extends Disposable, T>(
+			resourceFactory: () => TResource,
+			enumerableFactory: (resource: TResource) => Enumerable<T>): Enumerable<T>;
+
+		catch<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+		catchException<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+		onErrorResumeNext<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+		while<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
+		whileDo<T>(condition: EnumerablePredicate<Enumerable<T>>, source: Enumerable<T>): Enumerable<T>;
+
+		if<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
+		ifThen<T>(condition: () => boolean, thenSource: Enumerable<T>, elseSource?: Enumerable<T>): Enumerable<T>;
+
+		doWhile<T>(source: Enumerable<T>, condition: EnumerablePredicate<Enumerable<T>>): Enumerable<T>;
+
+		case<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		case<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		switchCase<T>(selector: () => number, sources: { [key: number]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+		switchCase<T>(selector: () => string, sources: { [key: string]: Enumerable<T>; }, defaultSource?: Enumerable<T>): Enumerable<T>;
+
+		for<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
+		forIn<T, TResult>(source: Enumerable<T>, resultSelector: EnumerableFunc<T, TResult>): Enumerable<TResult>;
+	}
+}
diff --git a/ix.js/l2o-tests.ts b/ix.js/l2o-tests.ts
new file mode 100644
index 000000000..2399d4e9f
--- /dev/null
+++ b/ix.js/l2o-tests.ts
@@ -0,0 +1,221 @@
+///<reference path="l2o.d.ts"/>
+
+var ec_ns = (a: number, b: string) => a.toString() == b;	//equality comparer on number,string
+var ec_nn = (a: number, b: number) => a === b;				//equality comparer on number,number
+var c_nn = (a: number, b: number) => a - b;					//comparer on number,number
+
+// static
+
+var ax = Ix.Enumerable.fromArray([0, 2, 7, 3, 4, 5]);
+
+var bx = Ix.Enumerable.create(() => {
+	var current = ".";
+	return Ix.Enumerator.create(
+		() => { current += "."; return true; },
+		() => current,
+		() => { });
+});
+
+Ix.Enumerator.create(() => true, () => 1);	// without dispose method
+
+var cx = Ix.Enumerable.empty<number>();
+
+var dx = Ix.Enumerable.concat(ax, cx);
+
+var ex = Ix.Enumerable.return(42);
+var fx = Ix.Enumerable.returnValue("42");
+
+var gx = Ix.Enumerable.range(-100, 200);
+
+Ix.Enumerable.repeat(42, 42);
+Ix.Enumerable.repeat(42);		// infinite
+
+Ix.Enumerable.sequenceEqual(ax, fx, ec_ns);
+Ix.Enumerable.sequenceEqual(ax, ex);	// default comparer on same type
+
+// instance
+
+ax.getEnumerator();
+
+ax.aggregate("", (acc, i) => acc + i, acc=> acc.length);
+ax.aggregate("", (acc, i) => acc + i);
+ax.aggregate((acc, i) => acc + i);
+
+ax.reduce((acc, i) => acc + i, 100);
+ax.reduce((acc, i) => acc + i);
+
+ax.all(item => true);
+ax.all(item => true, bx);
+ax.every(item => true);
+ax.every(item => true, bx);
+
+ax.any();
+ax.any(item => true);
+ax.any(item => true, bx);
+ax.some();
+ax.some(item => true);
+ax.some(item => true, bx);
+
+ax.average();
+bx.average(item => item.length);
+ax.min();
+bx.min(item => item.length);
+ax.max();
+bx.max(item => item.length);
+ax.sum();
+bx.sum(item => item.length);
+
+ax.concat(ax, cx, dx, ex, gx);
+
+ax.contains(10);
+ax.contains("10", ec_ns);
+
+ax.count();
+ax.count(item=>false);
+ax.count(item=> false, {});
+
+cx.defaultIfEmpty();
+cx.defaultIfEmpty(10);
+
+dx.distinct();
+dx.distinct((d1, d2) => d1 === d2);
+
+ax.elementAt(2);
+ax.elementAtOrDefault(2);
+
+//ax.except(bx, ec_ns);	// bug https://typescript.codeplex.com/workitem/1841
+bx.except(fx);
+
+ax.first();
+ax.firstOrDefault();
+ax.last();
+ax.lastOrDefault();
+ax.single();
+ax.singleOrDefault();
+
+ax.forEach(a => console.log(a));
+ax.forEach(a => console.log(a), cx);
+
+//bx.groupBy(b => b.length);						// spec 3.5.2, waiting for restriction on generative recursion removal
+bx.groupBy(b => b.length, b => "[" + b + "]");
+bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count());
+bx.groupBy(b => b.length, false, (l, values) => l + values.count());
+bx.groupBy(b => b.length, b => "[" + b + "]", (l, values) => l + values.count(), ec_nn);
+bx.groupBy(b => b.length, b => "[" + b + "]", false, (x, y) => x == y);
+bx.groupBy(b => b.length, false, (l, values) => l + values.count(), ec_nn);
+//bx.groupBy(b => b.length, false, false, ec_nn);	// spec 3.5.2, waiting for restriction on generative recursion removal
+
+ax.groupJoin(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
+ax.groupJoin(bx, a => a, b => b.length, (a, b) => [a, b]);
+
+ax.join(bx, a => a, b => b, (a, b) => [a, b], ec_ns);
+ax.join(bx, a => a, b => b.length, (a, b) => [a, b]);
+
+//ax.intersect(bx, ec_ns);	// bug https://typescript.codeplex.com/workitem/1841
+ax.intersect(cx);
+ax.union(cx);
+
+ax.orderBy(a=> -a).thenBy(a => a);
+ax.orderBy(a=> -a, c_nn).thenBy(a => a, c_nn);
+ax.orderByDescending(a=> -a).thenByDescending(a => a);
+ax.orderByDescending(a=> -a, c_nn).thenByDescending(a => a, c_nn);
+
+ax.reverse();
+
+ax.select(a=> a.toString());
+ax.select(a=> a.toString(), {});
+ax.map(a=> a.toString());
+ax.map(a=> a.toString(), {});
+
+ax.selectMany(a=> bx);
+ax.selectMany(a=> bx, (a, b) => [a, b]);
+
+ax.sequenceEqual(fx, ec_ns);
+ax.sequenceEqual(ax, ec_nn);
+ax.sequenceEqual(cx);
+
+ax.skip(10);
+ax.skipWhile(a => a > 10);
+ax.take(10);
+ax.takeWhile(a => a > 10);
+
+ax.toArray();
+
+bx.toDictionary(b => b.length, b => 10, ec_nn);
+//bx.toDictionary(b => b.length, false, ec_nn);	// spec 3.5.2, waiting for restriction on generative recursion removal
+bx.toDictionary(b => b.length, b => 10);
+//bx.toDictionary(b => b.length);				// spec 3.5.2, waiting for restriction on generative recursion removal
+
+bx.toLookup(b => b.length, b => 10, ec_nn);
+//bx.toLookup(b => b.length, false, ec_nn);		// spec 3.5.2, waiting for restriction on generative recursion removal
+bx.toLookup(b => b.length, b => 10);
+//bx.toLookup(b => b.length);					// spec 3.5.2, waiting for restriction on generative recursion removal
+
+ax.where(a=> a > 10, {});
+ax.where(a=> a > 10);
+ax.filter(a=> a > 10, {});
+ax.filter(a=> a > 10);
+
+ax.zip(bx, (a: number, b: string) => [a, b]);
+ax.zip(bx, (a, b) => [a, b]);
+
+// Disposable
+
+{
+	var d: Ix.Disposable;
+
+	d.dispose();
+}
+
+// Enumerator
+
+{
+	var e: Ix.Enumerator<number>;
+
+	try {
+		while (e.moveNext()) { var c = e.getCurrent(); }
+	}
+	finally {
+		e.dispose();
+	}
+}
+
+// Dictionary
+
+{
+	var dic = new Ix.Dictionary<number, string>(0, ec_nn);
+
+	var key = dic.toEnumerable().first().key;
+	var value = dic.toEnumerable().first().value;
+
+	dic.add(1, "1");
+	dic.remove(1);
+	dic.clear();
+	dic.length();
+	dic.tryGetValue(1);
+	dic.get(1);
+	dic.set(1, "1");
+	dic.getValues();
+	dic.has(1);
+}
+
+// KeyValuePair
+
+{
+	var kv: Ix.KeyValuePair<number, string>;
+	var key = kv.key;
+	var value = kv.value;
+}
+
+// Lookup
+
+{
+	var lookup: Ix.Lookup<number, string>;
+
+	var key = lookup.toEnumerable().first().key;
+	lookup.toEnumerable().first().first();
+
+	lookup.has(1);
+	lookup.length();
+	lookup.get(1).first();
+}
\ No newline at end of file
diff --git a/ix.js/l2o.d.ts b/ix.js/l2o.d.ts
new file mode 100644
index 000000000..c3f3c415e
--- /dev/null
+++ b/ix.js/l2o.d.ts
@@ -0,0 +1,256 @@
+// Type definitions for IxJS 1.0.6 / l2o.js
+// Project: https://github.com/Reactive-Extensions/IxJS
+// Definitions by: Igor Oleinikov <https://github.com/Igorbek>
+
+declare module Ix {
+	export interface Disposable {
+		dispose(): void;
+	}
+
+	export interface Enumerator<T> extends Disposable {
+		moveNext(): boolean;
+		getCurrent(): T;
+	}
+
+	export interface EnumeratorStatic {
+		new <T>(moveNext: () => boolean, getCurrent: () => T, dispose: () => void): Enumerator<T>;
+		create<T>(moveNext: () => boolean, getCurrent: () => T, dispose?: () => void): Enumerator<T>;
+	}
+
+	var Enumerator: EnumeratorStatic;
+
+	export interface EnumerableFunc<T, TResult> {
+		(item: T, index: number, self: Enumerable<T>): TResult;
+	}
+	export interface EnumerablePredicate<T> extends EnumerableFunc<T, boolean> { }
+	export interface Predicate<T> {
+		(item: T): boolean;
+	}
+	export interface EqualityComparer<TFirst, TSecond> {
+		(item1: TFirst, item2: TSecond): boolean;
+	}
+	export interface Comparer<TFirst, TSecond> {
+		(item1: TFirst, item2: TSecond): number;
+	}
+
+	export interface Enumerable<T> {
+		// base functions
+		getEnumerator(): Enumerator<T>;
+
+		// "extension" functions
+
+		aggregate<TAccumulate, TResult>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, resultSelector: (accumulate: TAccumulate) => TResult): TResult;
+		aggregate<TAccumulate>(seed: TAccumulate, func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate): TAccumulate;
+		aggregate(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+
+		reduce(func: (accumulate: T, current: T, index: number, self: Enumerable<T>) => T): T;
+		reduce<TAccumulate>(func: (accumulate: TAccumulate, current: T, index: number, self: Enumerable<T>) => TAccumulate, seed: TAccumulate): TAccumulate;
+
+		all(predicate: EnumerablePredicate<T>, thisArg?: any): boolean;
+		every(predicate: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+
+		any(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean;
+		some(predicate?: EnumerablePredicate<T>, thisArg?: any): boolean; // alias
+
+		average(selector?: EnumerableFunc<T, number>): number;
+		max(selector?: EnumerableFunc<T, number>): number;
+		min(selector?: EnumerableFunc<T, number>): number;
+		sum(selector?: EnumerableFunc<T, number>): number;
+
+		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+
+		contains<TValue>(value: TValue, comparer: EqualityComparer<T, TValue>): boolean;
+		contains(value: T): boolean;
+
+		count(predicate?: EnumerablePredicate<T>, thisArg?: any): number;
+
+		defaultIfEmpty(defaultValue?: T): Enumerable<T>;
+
+		distinct(comparer?: EqualityComparer<T, T>): Enumerable<T>;
+
+		elementAt(index: number): T;
+		elementAtOrDefault(index: number): T;
+
+		except<TOther>(second: Enumerable<TOther>, comparer: EqualityComparer<T, TOther>): Enumerable<T>;
+		except(second: Enumerable<T>): Enumerable<T>;
+
+		first(predicate?: Predicate<T>): T;
+		firstOrDefault(predicate?: Predicate<T>): T;
+		last(predicate?: Predicate<T>): T;
+		lastOrDefault(predicate?: Predicate<T>): T;
+		single(predicate?: Predicate<T>): T;
+		singleOrDefault(predicate?: Predicate<T>): T;
+
+		forEach(action: EnumerableFunc<T, void>, thisArg?: any): void;
+
+		groupBy<TKey, TElement, TResult>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement,
+			resultSelector: (key: TKey, values: Enumerable<TElement>) => TResult,
+			comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+		groupBy<TKey, TElement>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement): Grouping<TKey, TElement>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*groupBy<TKey>(
+			keySelector: (item: T) => TKey): Grouping<TKey, T>;*/
+
+		// if need to set comparer without resultSelector
+		groupBy<TKey, TElement>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TElement,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, TElement>;
+		// if need to set resultSelector without elementSelector
+		groupBy<TKey, TResult>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			resultSelector: (key: TKey, values: Enumerable<T>) => TResult,
+			comparer?: EqualityComparer<TKey, TKey>): Enumerable<TResult>;
+		// if need to set comparer without elementSelector and resultSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*groupBy<TKey>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			__: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Grouping<TKey, T>;*/
+
+		groupJoin<TInner, TOuterKey, TInnerKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TOuterKey,
+			innerKeySelector: (item: TInner) => TInnerKey,
+			resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult,
+			comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+		groupJoin<TInner, TKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TKey,
+			innerKeySelector: (item: TInner) => TKey,
+			resultSelector: (outer: T, innerSequence: Enumerable<TInner>) => TResult): Enumerable<TResult>;
+
+		join<TInner, TOuterKey, TInnerKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TOuterKey,
+			innerKeySelector: (item: TInner) => TInnerKey,
+			resultSelector: (outer: T, inner: TInner) => TResult,
+			comparer: EqualityComparer<TOuterKey, TInnerKey>): Enumerable<TResult>;
+		join<TInner, TKey, TResult>(
+			inner: Enumerable<TInner>,
+			outerKeySelector: (item: T) => TKey,
+			innerKeySelector: (item: TInner) => TKey,
+			resultSelector: (outer: T, inner: TInner) => TResult): Enumerable<TResult>;
+
+		intersect<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): Enumerable<T>;
+		intersect(second: Enumerable<T>): Enumerable<T>;
+		union(second: Enumerable<T>, comparer?: EqualityComparer<T, T>): Enumerable<T>;
+
+		orderBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+		orderByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+
+		reverse(): Enumerable<T>;
+
+		select<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+		map<TResult>(selector: EnumerableFunc<T, TResult>, thisArg?: any): Enumerable<TResult>;
+
+		selectMany<TCollection, TResult>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>,
+			resultSelector: (outer: T, inner: TCollection) => TResult): Enumerable<TResult>;
+		selectMany<TCollection>(collectionSelector: (item: T, index: number) => Enumerable<TCollection>): Enumerable<TCollection>;
+
+		sequenceEqual<TSecond>(second: Enumerable<TSecond>, comparer: EqualityComparer<T, TSecond>): boolean;
+		sequenceEqual(second: Enumerable<T>): boolean;
+
+		skip(count: number): Enumerable<T>;
+		skipWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		take(count: number): Enumerable<T>;
+		takeWhile(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+
+		toArray(): T[];
+
+		toDictionary<TKey, TValue>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TValue,
+			comparer?: EqualityComparer<TKey, TKey>): Dictionary<TKey, TValue>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toDictionary<TKey>(
+			keySelector: (item: T) => TKey): Dictionary<TKey, T>;*/
+		// if need to set comparer without elementSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toDictionary<TKey>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Dictionary<TKey, T>;*/
+
+		toLookup<TKey, TValue>(
+			keySelector: (item: T) => TKey,
+			elementSelector: (item: T) => TValue,
+			comparer?: EqualityComparer<TKey, TKey>): Lookup<TKey, TValue>;
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toLookup<TKey>(
+			keySelector: (item: T) => TKey): Lookup<TKey, T>;*/
+		// if need to set comparer without elementSelector
+		// spec 3.5.2, waiting for restriction on generative recursion removal
+		/*toLookup<TKey>(
+			keySelector: (item: T) => TKey,
+			_: boolean,
+			comparer: EqualityComparer<TKey, TKey>): Lookup<TKey, T>;*/
+
+		where(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+		filter(selector: EnumerablePredicate<T>, thisArg?: any): Enumerable<T>;
+
+		zip<TRight, TResult>(right: Enumerable<TRight>, selector: (left: T, right: TRight) => TResult): Enumerable<TResult>;
+	}
+
+	export interface Grouping<TKey, T> extends Enumerable<T> {
+		key: TKey;
+	}
+
+	export interface OrderedEnumerable<T> extends Enumerable<T> {
+		thenBy<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+		thenByDescending<TKey>(keySelector: (item: T) => TKey, comparer?: Comparer<TKey, TKey>): OrderedEnumerable<T>;
+	}
+
+	class Dictionary<TKey, TValue> {
+		constructor(capacity?: number, comparer?: EqualityComparer<TKey, TKey>);
+
+		toEnumerable(): Enumerable<KeyValuePair<TKey, TValue>>;
+
+		add(key: TKey, value: TValue): void;
+		remove(key: TKey): boolean;
+		clear(): void;
+		length(): number;
+		tryGetValue(key: TKey): TValue;
+		get(key: TKey): TValue;
+		set(key: TKey, value: TValue): void;
+		getValues(): TValue[];
+		has(key: TKey): boolean;
+	}
+
+	export interface KeyValuePair<TKey, TValue> {
+		key: TKey;
+		value: TValue;
+	}
+
+	export interface Lookup<TKey, TValue> {
+		toEnumerable(): Enumerable<Grouping<TKey, TValue>>;
+		has(key: TKey): boolean;
+		length(): number;
+		get(key: TKey): Enumerable<TValue>;
+	}
+
+	export interface EnumerableStatic {
+		new <T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+		create<T>(getEnumerator: () => Enumerator<T>): Enumerable<T>;
+
+		concat<T>(...sources: Enumerable<T>[]): Enumerable<T>;
+		empty<T>(): Enumerable<T>;
+		fromArray<T>(array: T[]): Enumerable<T>;
+		return<T>(value: T): Enumerable<T>;
+		returnValue<T>(value: T): Enumerable<T>;	// alias for <IE9
+		range(start: number, count: number): Enumerable<number>;
+		repeat<T>(value: T, repeatCount?: number): Enumerable<T>;
+
+		sequenceEqual<TFirst, TSecond>(first: Enumerable<TFirst>, second: Enumerable<TSecond>, comparer: EqualityComparer<TFirst, TSecond>): boolean;
+		sequenceEqual<T>(first: Enumerable<T>, second: Enumerable<T>): boolean;
+	}
+
+	var Enumerable: EnumerableStatic;
+}
\ No newline at end of file