diff --git a/linq/linq-tests.ts b/linq/linq-tests.ts
index b89625481..1fdd731cf 100644
--- a/linq/linq-tests.ts
+++ b/linq/linq-tests.ts
@@ -30,7 +30,7 @@ describe("Linq.js tests", function () {
     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() }; })
+            .Select((g: linq.Grouping<string>) => { 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");
diff --git a/linq/linq.d.ts b/linq/linq.d.ts
index d155ba806..461fe2eb0 100644
--- a/linq/linq.d.ts
+++ b/linq/linq.d.ts
@@ -1,6 +1,6 @@
 // Type definitions for linq.js 2.2
 // Project: http://linqjs.codeplex.com/
-// Definitions by: Marcin Najder <https://github.com/marcinnajder>
+// Definitions by: Marcin Najder <https://github.com/marcinnajder>, Sebastiaan Dammann <https://github.com/Sebazzz>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 // todo: jQuery plugin, RxJS Binding
@@ -8,107 +8,110 @@
 declare 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;
+        Choice<T>(...contents: T[]): Enumerable<T>;
+        Choice<T>(contents: T[]): Enumerable<T>;
+        Cycle<T>(...contents: T[]): Enumerable<T>;
+        Cycle<T>(contents: T[]): Enumerable<T>;
+        Empty<T>(): Enumerable<T>;
+        From<T>(obj: T[]): Enumerable<T>;
+        From(obj: number): Enumerable<number>; // input number returns single number
+        From(obj: string): Enumerable<string>; // input string returns sequence of characters
+        From(obj: NodeList): Enumerable<Node>; // node list returns sequence of nodes
+        From(obj: Object): Enumerable<KeyValuePair<string, any>>; // object returns sequence of key/value pairs
+        Return<T>(element: T): Enumerable<T>;
+        Matches<T>(input: string, pattern: RegExp): Enumerable<string>;
+        Matches<T>(input: string, pattern: string, flags?: string): Enumerable<string>;
+        Range(start: number, count: number, step?: number): Enumerable<number>;
+        RangeDown(start: number, count: number, step?: number): Enumerable<number>;
+        RangeTo(start: number, to: number, step?: number): Enumerable<number>;
+        Repeat<T>(obj: any, count?: number): Enumerable<T>;
+        RepeatWithFinalize<T>(initializer: () => T, finalizer: (resource: T) => void): Enumerable<T>;
+        Generate<T>(func: () => T, count?: number): Enumerable<T>;
+        Generate(func: string, count?: number): Enumerable<any>;
+        ToInfinity(start?: number, step?: number): Enumerable<number>;
+        ToNegativeInfinity(start?: number, step?: number): Enumerable<number>;
+        Unfold<T>(seed, func: ($) => T): Enumerable<T>;
+        Unfold(seed, func: string): Enumerable<any>;
     }
 
-    interface Enumerable {
+    interface Enumerable<T> {
         //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) => boolean): 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;
+        CascadeBreadthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable<any>;
+        CascadeBreadthFirst(func: string, resultSelector: string): Enumerable<any>;
+        CascadeDepthFirst(func: ($) => any[], resultSelector: (v, i: number) => any): Enumerable<any>;
+        CascadeDepthFirst(func: string, resultSelector: string): Enumerable<any>;
+        Flatten(...items: any[]): Enumerable<any>;
+        Pairwise(selector: (prev, next) => any): Enumerable<any>;
+        Pairwise(selector: string): Enumerable<any>;
+        Scan(func: (a, b) => any): Enumerable<any>;
+        Scan(func: string): Enumerable<any>;
+        Scan(seed, func: (a, b) => any, resultSelector?: ($) => any): Enumerable<any>;
+        Scan(seed, func: string, resultSelector?: string): Enumerable<any>;
+        Select<TResult>(selector: ($: T, i: number) => TResult): Enumerable<TResult>;
+        Select(selector: string): Enumerable<any>;
+        SelectMany(collectionSelector: ($, i: number) => any[], resultSelector?: ($, item) => any): Enumerable<any>;
+        SelectMany(collectionSelector: ($, i: number) => Enumerable<any>, resultSelector?: ($, item) => any): Enumerable<any>;
+        SelectMany(collectionSelector: string, resultSelector?: string): Enumerable<any>;
+        Where(predicate: ($ : T, i: number) => boolean): Enumerable<T>;
+        Where(predicate: string): Enumerable<any>;
+        OfType(type: Function): Enumerable<any>;
+        Zip(second: any[], selector: (v1, v2, i: number) => any): Enumerable<any>;
+        Zip(second: any[], selector: string): Enumerable<any>;
+        Zip(second: Enumerable<any>, selector: (v1, v2, i: number) => any): Enumerable<any>;
+        Zip(second: Enumerable<any>, selector: string): Enumerable<any>;
         //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;
+        Join(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable<any>;
+        Join(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
+        Join(inner: Enumerable<any>, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2) => any, compareSelector?: (v) => any): Enumerable<any>;
+        Join(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
+        GroupJoin(inner: any[], outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable<any>) => any, compareSelector?: (v) => any): Enumerable<any>;
+        GroupJoin(inner: any[], outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
+        GroupJoin(inner: Enumerable<any>, outerKeySelector: (v1) => any, innerKeySelector: (v1) => any, resultSelector: (v1, v2: Enumerable<any>) => any, compareSelector?: (v) => any): Enumerable<any>;
+        GroupJoin(inner: Enumerable<any>, outerKeySelector: string, innerKeySelector: string, resultSelector: string, compareSelector?: string): Enumerable<any>;
         //Set Methods
-        All(predicate: ($) => boolean): boolean;
+        All(predicate: ($ : T) => boolean): boolean;
         All(predicate: string): boolean;
-        Any(predicate?: ($) => boolean): boolean;
+        Any(predicate?: ($: T) => boolean): boolean;
         Any(predicate?: string): boolean;
-        Concat(second: any[]): Enumerable;
-        Concat(second: Enumerable): Enumerable;
-        Insert(index: number, second: any[]): Enumerable;
-        Insert(index: number, second: Enumerable): Enumerable;
-        Alternate(value): Enumerable;
+        Concat(second: any[]): Enumerable<any>;
+        Concat(second: Enumerable<any>): Enumerable<any>;
+        Insert(index: number, second: any[]): Enumerable<any>;
+        Insert(index: number, second: Enumerable<any>): Enumerable<any>;
+        Alternate(value): Enumerable<any>;
         Contains(value, compareSelector?: ($) => any): boolean;
         Contains(value, compareSelector?: string): boolean;
-        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;
+        DefaultIfEmpty(defaultValue): Enumerable<any>;
+        Distinct(compareSelector?: ($) => any): Enumerable<any>;
+        Distinct(compareSelector?: string): Enumerable<any>;
+        Except(second: any[], compareSelector?: ($) => any): Enumerable<any>;
+        Except(second: any[], compareSelector?: string): Enumerable<any>;
+        Except(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
+        Except(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
+        Intersect(second: any[], compareSelector?: ($) => any): Enumerable<any>;
+        Intersect(second: any[], compareSelector?: string): Enumerable<any>;
+        Intersect(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
+        Intersect(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
         SequenceEqual(second: any[], compareSelector?: ($) => any): boolean;
         SequenceEqual(second: any[], compareSelector?: string): boolean;
-        SequenceEqual(second: Enumerable, compareSelector?: ($) => any): boolean;
-        SequenceEqual(second: Enumerable, compareSelector?: string): boolean;
-        Union(second: any[], compareSelector?: ($) => any): Enumerable;
-        Union(second: any[], compareSelector?: string): Enumerable;
-        Union(second: Enumerable, compareSelector?: ($) => any): Enumerable;
-        Union(second: Enumerable, compareSelector?: string): Enumerable;
+        SequenceEqual(second: Enumerable<any>, compareSelector?: ($) => any): boolean;
+        SequenceEqual(second: Enumerable<any>, compareSelector?: string): boolean;
+        Union(second: any[], compareSelector?: ($) => any): Enumerable<any>;
+        Union(second: any[], compareSelector?: string): Enumerable<any>;
+        Union(second: Enumerable<any>, compareSelector?: ($) => any): Enumerable<any>;
+        Union(second: Enumerable<any>, compareSelector?: string): Enumerable<any>;
         //Ordering Methods
-        OrderBy(keySelector?: ($) => any): OrderedEnumerable;
-        OrderBy(keySelector?: string): OrderedEnumerable;
-        OrderByDescending(keySelector?: ($) => any): OrderedEnumerable;
-        OrderByDescending(keySelector?: string): OrderedEnumerable;
-        Reverse(): Enumerable;
-        Shuffle(): Enumerable;
+        OrderBy(keySelector?: ($: T) => any): OrderedEnumerable<T>;
+        OrderBy(keySelector?: string): OrderedEnumerable<T>;
+        OrderByDescending(keySelector?: ($) => any): OrderedEnumerable<T>;
+        OrderByDescending(keySelector?: string): OrderedEnumerable<T>;
+        Reverse(): Enumerable<T>;
+        Shuffle(): Enumerable<T>;
         //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;
+        GroupBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable<any>;
+        GroupBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
+        PartitionBy(keySelector: ($) => any, elementSelector?: ($) => any, resultSelector?: (key, e) => any, compareSelector?: ($) =>any): Enumerable<any>;
+        PartitionBy(keySelector: string, elementSelector?: string, resultSelector?: string, compareSelector?: string): Enumerable<any>;
+        BufferWithCount(count: number): Enumerable<any>;
         // Aggregate Methods
         Aggregate(func: (a, b) => any);
         Aggregate(seed, func: (a, b) => any, resultSelector?: ($) => any);
@@ -118,96 +121,108 @@ declare module linq {
         Average(selector?: string): number;
         Count(predicate?: ($) => boolean): 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;
+        Max(selector?: ($: T) => any): any;
+        Max(selector?: ($: T) => Date): Date;
+        Max(selector?: ($: T) => number): number;
+        Max(selector: ($: T) => string): string;
+        Max(selector?: string): any;
+        Min(selector?: ($: T) => any): any;
+        Min(selector?: ($: T) => Date): Date;
+        Min(selector: ($: T) => string): string;
+        Min(selector?: ($: T) => number): number;
+        Min(selector?: string): any;
+        MaxBy(selector: ($: T) => any): any;
+        MaxBy(selector: ($: T) => string): string;
+        MaxBy(selector: ($: T) => Date): Date;
+        MaxBy(selector: ($: T) => number): number;
         MaxBy(selector: string): any;
-        MinBy(selector: ($) => number): any;
+        MinBy(selector: ($: T) => Date): Date;
+        MinBy(selector: ($: T) => number): any;
+        MinBy(selector: ($: T) => string): string;
+        MinBy(selector: ($: T) => any): 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?: ($) => boolean): any;
-        First(predicate?: string): any;
-        FirstOrDefault(defaultValue, predicate?: ($) => boolean): any;
-        FirstOrDefault(defaultValue, predicate?: string): any;
-        Last(predicate?: ($) => boolean): any;
-        Last(predicate?: string): any;
-        LastOrDefault(defaultValue, predicate?: ($) => boolean): any;
-        LastOrDefault(defaultValue, predicate?: string): any;
-        Single(predicate?: ($) => boolean): any;
-        Single(predicate?: string): any;
-        SingleOrDefault(defaultValue, predicate?: ($) => boolean): any;
-        SingleOrDefault(defaultValue, predicate?: string): any;
-        Skip(count: number): Enumerable;
-        SkipWhile(predicate: ($, i: number) => boolean): Enumerable;
-        SkipWhile(predicate: string): Enumerable;
-        Take(count: number): Enumerable;
-        TakeWhile(predicate: ($, i: number) => boolean): Enumerable;
-        TakeWhile(predicate: string): Enumerable;
-        TakeExceptLast(count?: number): Enumerable;
-        TakeFromLast(count: number): Enumerable;
+        ElementAt(index: number): T;
+        ElementAtOrDefault(index: number, defaultValue: T): T;
+        First(predicate?: ($: T) => boolean): T;
+        First(predicate?: string): T;
+        FirstOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
+        FirstOrDefault(defaultValue: T, predicate?: string): T;
+        Last(predicate?: ($: T) => boolean): T;
+        Last(predicate?: string): T;
+        LastOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
+        LastOrDefault(defaultValue: T, predicate?: string): T;
+        Single(predicate?: ($: T) => boolean): T;
+        Single(predicate?: string): T;
+        SingleOrDefault(defaultValue: T, predicate?: ($: T) => boolean): T;
+        SingleOrDefault(defaultValue: T, predicate?: string): T;
+        Skip(count: number): Enumerable<T>;
+        SkipWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
+        SkipWhile(predicate: string): Enumerable<T>;
+        Take(count: number): Enumerable<T>;
+        TakeWhile(predicate: ($: T, i: number) => boolean): Enumerable<T>;
+        TakeWhile(predicate: string): Enumerable<T>;
+        TakeExceptLast(count?: number): Enumerable<T>;
+        TakeFromLast(count: number): Enumerable<T>;
         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;
+        ToArray(): T[];
+        ToLookup(keySelector: ($) => any, elementSelector?: ($) => any, compareSelector?: (key) => any): Lookup<T>;
+        ToLookup(keySelector: string, elementSelector?: string, compareSelector?: string): Lookup<T>;
         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;
+        ToDictionary(keySelector: ($) => any, elementSelector: ($) => any, compareSelector?: (key) => any): Dictionary<T>;
+        ToDictionary(keySelector: string, elementSelector: string, compareSelector?: string): Dictionary<T>;
         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) => boolean): void;
+        Do(action: ($, i: number) => void ): Enumerable<any>;
+        Do(action: string): Enumerable<any>;
+        ForEach(action: ($: T, i: number) => void ): void;
+        ForEach(func: ($: T, i: number) => boolean): 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;
+        Let(func: (e: Enumerable<any>) => Enumerable<any>): Enumerable<any>;
+        Share(): Enumerable<any>;
+        MemoizeAll(): Enumerable<any>;
         //Error Handling Methods
-        Catch(handler: (error: Error) => void ): Enumerable;
-        Catch(handler: string): Enumerable;
-        Finally(finallyAction: () => void ): Enumerable;
-        Finally(finallyAction: string): Enumerable;
+        Catch(handler: (error: Error) => void ): Enumerable<any>;
+        Catch(handler: string): Enumerable<any>;
+        Finally(finallyAction: () => void ): Enumerable<any>;
+        Finally(finallyAction: string): Enumerable<any>;
         //For Debug Methods
-        Trace(message?: string, selector?: ($) =>any): Enumerable;
-        Trace(message?: string, selector?: string): Enumerable;
+        Trace(message?: string, selector?: ($) =>any): Enumerable<any>;
+        Trace(message?: string, selector?: string): Enumerable<any>;
     }
 
-    interface OrderedEnumerable extends Enumerable {
-        ThenBy(keySelector: ($) => any): OrderedEnumerable;
-        ThenBy(keySelector: string): OrderedEnumerable;
-        ThenByDescending(keySelector: ($) => any): OrderedEnumerable;
-        ThenByDescending(keySelector: string): OrderedEnumerable;
+    interface OrderedEnumerable<T> extends Enumerable<T> {
+        ThenBy(keySelector: ($) => T): OrderedEnumerable<T>;
+        ThenBy(keySelector: string): OrderedEnumerable<T>;
+        ThenByDescending(keySelector: ($) => T): OrderedEnumerable<T>;
+        ThenByDescending(keySelector: T): OrderedEnumerable<T>;
     }
 
-    interface Grouping extends Enumerable {
+    interface Grouping<T> extends Enumerable<T> {
         Key();
     }
 
-    interface Lookup {
+    interface Lookup<TValue> {
         Count(): number;
-        Get(key): Enumerable;
+        Get(key): Enumerable<TValue>;
         Contains(key): boolean;
-        ToEnumerable(): Enumerable;
+        ToEnumerable(): Enumerable<TValue>;
     }
 
-    interface Dictionary {
+    interface Dictionary<TValue> {
         Add(key, value): void;
         Get(key): any;
         Set(key, value): boolean;
@@ -215,7 +230,12 @@ declare module linq {
         Clear(): void;
         Remove(key): void;
         Count(): number;
-        ToEnumerable(): Enumerable;
+        ToEnumerable(): Enumerable<TValue>;
+    }
+
+    interface KeyValuePair<TKey, TValue> {
+        Key: TKey;
+        Value: TValue;
     }
 }