diff --git a/Definitions/linq-2.2.0.2.d.ts b/Definitions/linq-2.2.0.2.d.ts
new file mode 100644
index 000000000..0cf528287
--- /dev/null
+++ b/Definitions/linq-2.2.0.2.d.ts
@@ -0,0 +1,220 @@
+// http://linqjs.codeplex.com/
+// 2.2.0.2
+
+// todo: jQuery plugin, RxJS Binding
+
+module linq {
+
+    interface EnumerableStatic {
+        Choice(...contents: any[]): Enumerable;
+        Choice(contents: any[]): Enumerable;
+        Cycle(...contents: any[]): Enumerable;
+        Cycle(contents: any[]): Enumerable;
+        Empty(): Enumerable;
+        From(obj: any[]): Enumerable;
+        From(obj: any): Enumerable;
+        Return(element: any): Enumerable;
+        Matches(input: string, pattern: RegExp): Enumerable;
+        Matches(input: string, pattern: string, flags?: string): Enumerable;
+        Range(start: number, count: number, step?: number): Enumerable;
+        RangeDown(start: number, count: number, step?: number): Enumerable;
+        RangeTo(start: number, to: number, step?: number): Enumerable;
+        Repeat(obj: any, count?: number): Enumerable;
+        RepeatWithFinalize(initializer: () => any, finalizer: (resource: any) =>void ): Enumerable;
+        Generate(func: () => any, count?: number): Enumerable;
+        Generate(func: string, count?: number): Enumerable;
+        ToInfinity(start?: number, step?: number): Enumerable;
+        ToNegativeInfinity(start?: number, step?: number): Enumerable;
+        Unfold(seed, func: ($) => any): Enumerable;
+        Unfold(seed, func: string): Enumerable;
+    }
+
+    interface Enumerable {
+        //Projection and Filtering Methods
+        CascadeBreadthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
+        CascadeBreadthFirst(func: string, resultSelector: string): Enumerable;
+        CascadeDepthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable;
+        CascadeDepthFirst(func: string, resultSelector: string): Enumerable;
+        Flatten(...items: any[]): Enumerable;
+        Pairwise(selector: (prev, next) => any): Enumerable;
+        Pairwise(selector: string): Enumerable;
+        Scan(func: (a, b) => any): Enumerable;
+        Scan(func: string): Enumerable;
+        Scan(seed, func: (a, b) => any, resultSelector?: ($) => any): Enumerable;
+        Scan(seed, func: string, resultSelector?: string): Enumerable;
+        Select(selector: ($, i: number) => any): Enumerable;
+        Select(selector: string): Enumerable;
+        SelectMany(collectionSelector: ($, i: number) => any[], resultSelector?: ($, item) => any): Enumerable;
+        SelectMany(collectionSelector: ($, i: number) => Enumerable, resultSelector?: ($, item) => any): Enumerable;
+        SelectMany(collectionSelector: string, resultSelector?: string): Enumerable;
+        Where(predicate: ($, i: number) => bool): Enumerable;
+        Where(predicate: string): Enumerable;
+        OfType(type: Function): Enumerable;
+        Zip(second: any[], selector: (v1, v2, i: number) => any): Enumerable;
+        Zip(second: any[], selector: string): Enumerable;
+        Zip(second: Enumerable, selector: (v1, v2, i: number) => any): Enumerable;
+        Zip(second: Enumerable, selector: string): Enumerable;
+        //Join Methods
+        Join(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
+        Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
+        Join(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable;
+        Join(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
+        GroupJoin(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
+        GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
+        GroupJoin(inner: Enumerable, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable) => any, compareSelector?: (v) => any): Enumerable;
+        GroupJoin(inner: Enumerable, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable;
+        //Set Methods
+        All(predicate: ($) => bool): bool;
+        All(predicate: string): bool;
+        Any(predicate?: ($) => bool): bool;
+        Any(predicate?: string): bool;
+        Concat(second: any[]): Enumerable;
+        Concat(second: Enumerable): Enumerable;
+        Insert(index: number, second: any[]): Enumerable;
+        Insert(index: number, second: Enumerable): Enumerable;
+        Alternate(value): Enumerable;
+        Contains(value, compareSelector?: ($) => any): bool;
+        Contains(value, compareSelector?: string): bool;
+        DefaultIfEmpty(defaultValue): Enumerable;
+        Distinct(compareSelector?: ($) => any): Enumerable;
+        Distinct(compareSelector?: string): Enumerable;
+        Except(second: any[], compareSelector?: ($) => any): Enumerable;
+        Except(second: any[], compareSelector?: string): Enumerable;
+        Except(second: Enumerable, compareSelector?: ($) => any): Enumerable;
+        Except(second: Enumerable, compareSelector?: string): Enumerable;
+        Intersect(second: any[], compareSelector?: ($) => any): Enumerable;
+        Intersect(second: any[], compareSelector?: string): Enumerable;
+        Intersect(second: Enumerable, compareSelector?: ($) => any): Enumerable;
+        Intersect(second: Enumerable, compareSelector?: string): Enumerable;
+        SequenceEqual(second: any[], compareSelector?: ($) => any): bool;
+        SequenceEqual(second: any[], compareSelector?: string): bool;
+        SequenceEqual(second: Enumerable, compareSelector?: ($) => any): bool;
+        SequenceEqual(second: Enumerable, compareSelector?: string): bool;
+        Union(second: any[], compareSelector?: ($) => any): Enumerable;
+        Union(second: any[], compareSelector?: string): Enumerable;
+        Union(second: Enumerable, compareSelector?: ($) => any): Enumerable;
+        Union(second: Enumerable, compareSelector?: string): Enumerable;
+        //Ordering Methods
+        OrderBy(keySelector?: ($) => any): OrderedEnumerable;
+        OrderBy(keySelector?: string): OrderedEnumerable;
+        OrderByDescending(keySelector?: ($) => any): OrderedEnumerable;
+        OrderByDescending(keySelector?: string): OrderedEnumerable;
+        Reverse(): Enumerable;
+        Shuffle(): Enumerable;
+        //Grouping Methods
+        GroupBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
+        GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
+        PartitionBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable;
+        PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable;
+        BufferWithCount(count: number): Enumerable;
+        // Aggregate Methods
+        Aggregate(func: (a, b) => any);
+        Aggregate(seed, func: (a, b) => any, resultSelector?: ($) => any);
+        Aggregate(func: string);
+        Aggregate(seed, func: string, resultSelector?: string);
+        Average(selector?: ($) => number): number;
+        Average(selector?: string): number;
+        Count(predicate?: ($) => bool): number;
+        Count(predicate?: string): number;
+        Max(selector?: ($) => number): number;
+        Max(selector?: string): number;
+        Min(selector?: ($) => number): number;
+        Min(selector?: string): number;
+        MaxBy(selector: ($) => number): any;
+        MaxBy(selector: string): any;
+        MinBy(selector: ($) => number): any;
+        MinBy(selector: string): any;
+        Sum(selector?: ($) => number): number;
+        Sum(selector?: string): number;
+        //Paging Methods
+        ElementAt(index: number): any;
+        ElementAtOrDefault(index: number, defaultValue): any;
+        First(predicate?: ($) => bool): any;
+        First(predicate?: string): any;
+        FirstOrDefault(defaultValue, predicate?: ($) => bool): any;
+        FirstOrDefault(defaultValue, predicate?: string): any;
+        Last(predicate?: ($) => bool): any;
+        Last(predicate?: string): any;
+        LastOrDefault(defaultValue, predicate?: ($) => bool): any;
+        LastOrDefault(defaultValue, predicate?: string): any;
+        Single(predicate?: ($) => bool): any;
+        Single(predicate?: string): any;
+        SingleOrDefault(defaultValue, predicate?: ($) => bool): any;
+        SingleOrDefault(defaultValue, predicate?: string): any;
+        Skip(count: number): Enumerable;
+        SkipWhile(predicate: ($, i: number) => bool): Enumerable;
+        SkipWhile(predicate: string): Enumerable;
+        Take(count: number): Enumerable;
+        TakeWhile(predicate: ($, i: number) => bool): Enumerable;
+        TakeWhile(predicate: string): Enumerable;
+        TakeExceptLast(count?: number): Enumerable;
+        TakeFromLast(count: number): Enumerable;
+        IndexOf(item): number;
+        LastIndexOf(item): number;
+        // Convert Methods
+        ToArray(): any[];
+        ToLookup(keySelector: ($) => any, elementSelector?: ($) => any, compareSelector?: (key) => any): Lookup;
+        ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup;
+        ToObject(keySelector: ($) => string, elementSelector: ($) => any): any;
+        ToObject(keySelector: string, elementSelector: string): any;
+        ToDictionary(keySelector: ($) => any, elementSelector: ($) => any, compareSelector?: (key) => any): Dictionary;
+        ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary;
+        ToJSON(replacer?: (key, value) => any, space?: number): string;
+        ToJSON(replacer?: string, space?: number): string;
+        ToString(separator?: string, selector?: ($) =>any): string;
+        ToString(separator?: string, selector?: string): string;
+        //Action Methods
+        Do(action: ($, i: number) => void ): Enumerable;
+        Do(action: string): Enumerable;
+        ForEach(action: ($, i: number) => void ): void;
+        ForEach(func: ($, i: number) => bool): void;
+        ForEach(action_func: string): void;
+        Write(separator?: string, selector?: ($) =>any): void;
+        Write(separator?: string, selector?: string): void;
+        WriteLine(selector?: ($) =>any): void;
+        Force(): void;
+        //Functional Methods
+        Let(func: (e: Enumerable) => Enumerable): Enumerable;
+        Share(): Enumerable;
+        MemoizeAll(): Enumerable;
+        //Error Handling Methods
+        Catch(handler: (error: Error) => void ): Enumerable;
+        Catch(handler: string): Enumerable;
+        Finally(finallyAction: () => void ): Enumerable;
+        Finally(finallyAction: string): Enumerable;
+        //For Debug Methods
+        Trace(message?: string, selector?: ($) =>any): Enumerable;
+        Trace(message?: string, selector?: string): Enumerable;
+    }
+
+    interface OrderedEnumerable extends Enumerable {
+        ThenBy(keySelector: ($) => any): OrderedEnumerable;
+        ThenBy(keySelector: string): OrderedEnumerable;
+        ThenByDescending(keySelector: ($) => any): OrderedEnumerable;
+        ThenByDescending(keySelector: string): OrderedEnumerable;
+    }
+
+    interface Grouping extends Enumerable {
+        Key();
+    }
+
+    interface Lookup {
+        Count(): number;
+        Get(key): Enumerable;
+        Contains(key): bool;
+        ToEnumerable(): Enumerable;
+    }
+
+    interface Dictionary {
+        Add(key, value): void;
+        Get(key): any;
+        Set(key, value): bool;
+        Contains(key): bool;
+        Clear(): void;
+        Remove(key): void;
+        Count(): number;
+        ToEnumerable(): Enumerable;
+    }
+}
+
+declare var Enumerable: linq.EnumerableStatic;
\ No newline at end of file
diff --git a/Tests/linq-tests.ts b/Tests/linq-tests.ts
new file mode 100644
index 000000000..56e36fdab
--- /dev/null
+++ b/Tests/linq-tests.ts
@@ -0,0 +1,39 @@
+/// <reference path='../Definitions/jasmine-1.2.d.ts'/>
+/// <reference path='../Definitions/linq-2.2.0.2.d.ts'/>
+// <reference path="c:/linq.js" /> tests were run from VisualStudio + Resharper7
+
+describe("Linq.js tests", function () {
+    it("Projection and Filtering Methods", function () {
+        expect(Enumerable.From([1,2,3,4]).ToString(",")).toBe("1,2,3,4");
+        expect(Enumerable.Range(1, 4).Where((item: number) => item > 2).ToString(",")).toBe("3,4");
+        expect(Enumerable.Range(1, 4).Where("(item) => item > 2").ToString(",")).toBe("3,4");
+        expect(Enumerable.Range(1, 4).Where("$>2").ToString(",")).toBe("3,4");
+        expect(Enumerable.Range(1, 4).Select((item: number,index:number) => item+index).ToString(",")).toBe("1,3,5,7");
+        expect(Enumerable.Range(1, 4).Zip(Enumerable.Range(1, 10),  (a: number,b:number) => a-b).ToString(",")).toBe("0,0,0,0");
+
+    });
+    it("Join Methods", function () {
+        expect(Enumerable.Range(1, 4).Join(Enumerable.From(["a", "aaa"]), (l) => l, (r: string) => r.length, (l, r) =>l + ":" + r).ToString(",")).toBe("1:a,3:aaa");
+    });
+    it("Set Methods", function () {
+        expect(Enumerable.Range(2, 4, 2).All((item: number) => item % 2 == 0)).toBe(true);
+        expect(Enumerable.Range(1, 4).Intersect(Enumerable.Range(3, 4)).ToString(",")).toBe("3,4");
+    });
+    it("Ordering Methods", function () {
+        expect(Enumerable.From(
+        [
+            { name: "marcin", age:15},
+            { name: "albert", age:51},            
+            { name: "marcin", age:30},
+        ]).OrderBy((p) => p.name).ThenByDescending((p) => p.age).Select((p) => p.name+p.age).ToString(",")).toBe("albert51,marcin30,marcin15");
+    });
+    it("Grouping Methods", function () {
+        expect(Enumerable.From(["a","aa","aaa","a","a","aaa"])
+            .GroupBy((item:string) => item.length)
+            .Select((g: linq.Grouping) => { return { key: g.Key(), count: g.Count() }; })
+            .OrderBy(g => g.key)
+            .Select(g => g.key+":"+g.count)
+            .ToString(",")).toBe("1:3,2:1,3:2");
+    });
+});
+