diff --git a/lazy.js/lazy.js-tests.ts b/lazy.js/lazy.js-tests.ts
index 356ee177b5..7689bcaf78 100644
--- a/lazy.js/lazy.js-tests.ts
+++ b/lazy.js/lazy.js-tests.ts
@@ -1,9 +1,33 @@
 /// <reference path="lazy.js.d.ts" />
 
-var sequence: LazyJS.Sequence;
-var arraySeq: LazyJS.ArrayLikeSequence;
-var objectSeq: LazyJS.ObjectLikeSequence;
-var asyncSeq: LazyJS.AsyncSequence;
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+interface Foo {
+	foo(): string;
+}
+interface Bar {
+	bar(): string;
+}
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var foo: Foo;
+var bar: Bar;
+
+var fooArr: Foo[];
+var barArr: Bar[];
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+var fooSequence: LazyJS.Sequence<Foo>;
+var barSequence: LazyJS.Sequence<Bar>;
+var fooArraySeq: LazyJS.ArrayLikeSequence<Foo>;
+var barArraySeq: LazyJS.ArrayLikeSequence<Bar>;
+var fooObjectSeq: LazyJS.ObjectLikeSequence<Foo>;
+var anyObjectSeq: LazyJS.ObjectLikeSequence<any>;
+var fooAsyncSeq: LazyJS.AsyncSequence<Foo>;
+
+var strSequence: LazyJS.Sequence<string>;
 var stringSeq: LazyJS.StringLikeSequence;
 
 var obj: Object;
@@ -23,141 +47,142 @@ function fnErrorCallback(error: any): void {
 
 }
 
-function fnValueCallback(value: any): void {
+function fnValueCallback(value: Foo): void {
 }
 
-function fnGetKeyCallback(value: any): string {
-	return '';
+function fnGetKeyCallback(value: Foo): string {
+	return str;
 }
 
-function fnTestCallback(value: any): boolean {
-	return false;
+function fnTestCallback(value: Foo): boolean {
+	return bool;
 }
 
-function fnMapCallback(value: any): any {
-	return null;
+function fnMapCallback(value: Foo): Bar {
+	return bar;
 }
 
 function fnMapStringCallback(value: string): string {
-	return '';
+	return str;
 }
 
-function fnNumberCallback(value: any): number {
-	return 0;
+function fnNumberCallback(value: Foo): number {
+	return num;
 }
 
-function fnMemoCallback(memo: any, value: any): any {
-	return null;
+function fnMemoCallback(memo: Bar, value: Foo): Bar {
+	return bar;
 }
 
-function fnGeneratorCallback(index: number): any {
-	return null;
+function fnGeneratorCallback(index: number): Foo {
+	return foo;
 }
 
 // Lazy
 
-arraySeq = Lazy([]);
-objectSeq = Lazy({});
-stringSeq = Lazy('');
+fooArraySeq = Lazy(fooArr);
+fooObjectSeq = Lazy<Foo>({a:foo, b:foo});
+anyObjectSeq = Lazy<any>({a:num, b:str});
+stringSeq = Lazy(str);
 
 // Strict
 
 var Strict = Lazy.strict();
-arraySeq = Strict([1, 2, num]).pop();
+fooArraySeq = Strict([foo, foo]).pop();
 
 // Sequence
 
-asyncSeq = sequence.async(num);
-sequence = sequence.chunk(num);
-sequence = sequence.compact();
-sequence = sequence.concat(arr);
-sequence = sequence.consecutive(num);
-bool = sequence.contains(x);
-sequence = sequence.countBy(str);
-sequence = sequence.countBy(fnGetKeyCallback);
-sequence = sequence.dropWhile(fnTestCallback);
-sequence = sequence.each(fnValueCallback);
-bool = sequence.every(fnTestCallback);
-sequence = sequence.filter(fnTestCallback);
-sequence = sequence.find(fnTestCallback);
-sequence = sequence.findWhere(obj);
+fooAsyncSeq = fooSequence.async(num);
+fooSequence = fooSequence.chunk(num);
+fooSequence = fooSequence.compact();
+fooSequence = fooSequence.concat(arr);
+fooSequence = fooSequence.consecutive(num);
+bool = fooSequence.contains(foo);
+fooSequence = fooSequence.countBy(str);
+fooObjectSeq = fooSequence.countBy(fnGetKeyCallback);
+fooSequence = fooSequence.dropWhile(fnTestCallback);
+fooSequence = fooSequence.each(fnValueCallback);
+bool = fooSequence.every(fnTestCallback);
+fooSequence = fooSequence.filter(fnTestCallback);
+fooSequence = fooSequence.find(fnTestCallback);
+fooSequence = fooSequence.findWhere(obj);
 
-x = sequence.first();
-sequence = sequence.first(num);
+x = fooSequence.first();
+fooSequence = fooSequence.first(num);
 
-sequence = sequence.flatten();
-objectSeq = sequence.groupBy(fnGetKeyCallback);
-sequence = sequence.indexOf(x);
-sequence = sequence.initial();
-sequence = sequence.initial(num);
-sequence = sequence.intersection(arr);
-sequence = sequence.invoke(str);
-bool = sequence.isEmpty();
-str = sequence.join();
-str = sequence.join(str);
+fooSequence = fooSequence.flatten();
+fooObjectSeq = fooSequence.groupBy(fnGetKeyCallback);
+fooSequence = fooSequence.indexOf(x);
+fooSequence = fooSequence.initial();
+fooSequence = fooSequence.initial(num);
+fooSequence = fooSequence.intersection(arr);
+fooSequence = fooSequence.invoke(str);
+bool = fooSequence.isEmpty();
+str = fooSequence.join();
+str = fooSequence.join(str);
 
-x = sequence.last();
-sequence = sequence.last(num);
+foo = fooSequence.last();
+fooSequence = fooSequence.last(num);
 
-sequence = sequence.lastIndexOf(x);
-sequence = sequence.map(fnMapCallback);
-x = sequence.max();
-x = sequence.max(fnNumberCallback);
-x = sequence.min();
-x = sequence.min(fnNumberCallback);
-sequence = sequence.pluck(str);
-x = sequence.reduce(fnMemoCallback);
-x = sequence.reduce(fnMemoCallback, x);
-x = sequence.reduceRight(fnMemoCallback, x);
-sequence = sequence.reject(fnTestCallback);
-sequence = sequence.rest(num);
-sequence = sequence.reverse();
-sequence = sequence.shuffle();
-bool = sequence.some();
-bool = sequence.some(fnTestCallback);
-sequence = sequence.sortBy(fnNumberCallback);
-sequence = sequence.sortedIndex(x);
-sequence = sequence.sum();
-sequence = sequence.sum(fnNumberCallback);
-sequence = sequence.takeWhile(fnTestCallback);
-sequence = sequence.union(arr);
-sequence = sequence.uniq();
-sequence = sequence.where(obj);
-sequence = sequence.without(arr);
-sequence = sequence.zip(arr);
+fooSequence = fooSequence.lastIndexOf(foo);
+barSequence = fooSequence.map(fnMapCallback);
+foo = fooSequence.max();
+foo = fooSequence.max(fnNumberCallback);
+foo = fooSequence.min();
+foo = fooSequence.min(fnNumberCallback);
+fooSequence = fooSequence.pluck(str);
+bar = fooSequence.reduce(fnMemoCallback);
+bar = fooSequence.reduce(fnMemoCallback, bar);
+bar = fooSequence.reduceRight(fnMemoCallback, bar);
+fooSequence = fooSequence.reject(fnTestCallback);
+fooSequence = fooSequence.rest(num);
+fooSequence = fooSequence.reverse();
+fooSequence = fooSequence.shuffle();
+bool = fooSequence.some();
+bool = fooSequence.some(fnTestCallback);
+fooSequence = fooSequence.sortBy(fnNumberCallback);
+fooSequence = fooSequence.sortedIndex(foo);
+fooSequence = fooSequence.sum();
+fooSequence = fooSequence.sum(fnNumberCallback);
+fooSequence = fooSequence.takeWhile(fnTestCallback);
+fooSequence = fooSequence.union(fooArr);
+fooSequence = fooSequence.uniq();
+fooSequence = fooSequence.where(obj);
+fooSequence = fooSequence.without(fooArr);
+fooSequence = fooSequence.zip(arr);
 
-arr = sequence.toArray();
-obj = sequence.toObject();
+fooArr = fooSequence.toArray();
+obj = fooSequence.toObject();
 
 // ArrayLikeSequence
 
-arraySeq = arraySeq.concat();
-arraySeq = arraySeq.first();
-arraySeq = arraySeq.first(num);
-x = arraySeq.get(num);
-num = arraySeq.length();
-arraySeq = arraySeq.map(fnMapCallback);
-arraySeq = arraySeq.pop();
-arraySeq = arraySeq.rest();
-arraySeq = arraySeq.rest(num);
-arraySeq = arraySeq.reverse();
-arraySeq = arraySeq.shift();
-arraySeq = arraySeq.slice(num);
-arraySeq = arraySeq.slice(num, num);
+fooArraySeq = fooArraySeq.concat();
+fooArraySeq = fooArraySeq.first();
+fooArraySeq = fooArraySeq.first(num);
+foo = fooArraySeq.get(num);
+num = fooArraySeq.length();
+barArraySeq = fooArraySeq.map(fnMapCallback);
+fooArraySeq = fooArraySeq.pop();
+fooArraySeq = fooArraySeq.rest();
+fooArraySeq = fooArraySeq.rest(num);
+fooArraySeq = fooArraySeq.reverse();
+fooArraySeq = fooArraySeq.shift();
+fooArraySeq = fooArraySeq.slice(num);
+fooArraySeq = fooArraySeq.slice(num, num);
 
 // ObjectLikeSequence
 
-objectSeq = objectSeq.defaults(obj);
-sequence = objectSeq.functions();
-objectSeq = objectSeq.get(str);
-objectSeq = objectSeq.invert();
-sequence = objectSeq.keys();
-objectSeq = objectSeq.omit(strArr);
-sequence = objectSeq.pairs();
-objectSeq = objectSeq.pick(strArr);
-arr = objectSeq.toArray();
-obj = objectSeq.toObject();
-sequence = objectSeq.values();
+fooObjectSeq = fooObjectSeq.defaults(obj);
+fooSequence = fooObjectSeq.functions();
+fooObjectSeq = fooObjectSeq.get(str);
+fooObjectSeq = fooObjectSeq.invert();
+strSequence = fooObjectSeq.keys();
+fooObjectSeq = fooObjectSeq.omit(strArr);
+fooSequence = fooObjectSeq.pairs();
+fooObjectSeq = fooObjectSeq.pick(strArr);
+arr = fooObjectSeq.toArray();
+obj = fooObjectSeq.toObject();
+fooSequence = fooObjectSeq.values();
 
 // StringLikeSequence
 
@@ -181,8 +206,8 @@ stringSeq = stringSeq.mapString(fnMapStringCallback);
 stringSeq = stringSeq.match(exp);
 stringSeq = stringSeq.reverse();
 
-sequence = stringSeq.split(str);
-sequence = stringSeq.split(exp);
+stringSeq = stringSeq.split(str);
+stringSeq = stringSeq.split(exp);
 
 bool = stringSeq.startsWith(str);
 stringSeq = stringSeq.substring(num);
diff --git a/lazy.js/lazy.js.d.ts b/lazy.js/lazy.js.d.ts
index 47925bdf94..ca19aed983 100644
--- a/lazy.js/lazy.js.d.ts
+++ b/lazy.js/lazy.js.d.ts
@@ -6,28 +6,31 @@
 declare module LazyJS {
 
 	interface LazyStatic {
-		(value:string):StringLikeSequence;
-		(value:any[]):ArrayLikeSequence;
-		(value:Object):ObjectLikeSequence;
-		(value:ArrayLike):ArrayLikeSequence;
+
+		(value: string):StringLikeSequence;
+		<T>(value: T[]):ArrayLikeSequence<T>;
+		(value: any[]):ArrayLikeSequence<any>;
+		<T>(value: Object):ObjectLikeSequence<T>;
+		(value: Object):ObjectLikeSequence<any>;
 
 		strict():LazyStatic;
 
-		generate(generatorFn:GeneratorCallback, length?:number):GeneratedSequence;
+		generate<T>(generatorFn: GeneratorCallback<T>, length?: number):GeneratedSequence<T>;
 
-		range(to:number):GeneratedSequence;
-		range(from:number, to:number, step?:number):GeneratedSequence;
+		range(to: number):GeneratedSequence<number>;
+		range(from: number, to: number, step?: number):GeneratedSequence<number>;
 
-		repeat(value:any, count?:number):GeneratedSequence;
+		repeat<T>(value: T, count?: number):GeneratedSequence<T>;
 
-		on(eventType:string):Sequence;
+		on<T>(eventType: string):Sequence<T>;
 
-		readFile(path:string):StringLikeSequence;
-		makeHttpRequest(path:string):StringLikeSequence;
+		readFile(path: string):StringLikeSequence;
+		makeHttpRequest(path: string):StringLikeSequence;
 	}
 
-	interface ArrayLike {
+	interface ArrayLike<T> {
 		length:number;
+		[index:number]:T;
 	}
 
 	interface Callback {
@@ -35,212 +38,213 @@ declare module LazyJS {
 	}
 
 	interface ErrorCallback {
-		(error:any):void;
+		(error: any):void;
 	}
 
-	interface ValueCallback {
-		(value:any):void;
+	interface ValueCallback<T> {
+		(value: T):void;
 	}
 
-	interface GetKeyCallback {
-		(value:any):string;
+	interface GetKeyCallback<T> {
+		(value: T):string;
 	}
 
-	interface TestCallback {
-		(value:any):boolean;
+	interface TestCallback<T> {
+		(value: T):boolean;
 	}
 
-	interface MapCallback {
-		(value:any):any;
+	interface MapCallback<T, U> {
+		(value: T):U;
 	}
 
 	interface MapStringCallback {
-		(value:string):string;
+		(value: string):string;
 	}
 
-	interface NumberCallback {
-		(value:any):number;
+	interface NumberCallback<T> {
+		(value: T):number;
 	}
 
-	interface MemoCallback {
-		(memo:any, value:any):any;
+	interface MemoCallback<T, U> {
+		(memo: U, value: T):U;
 	}
 
-	interface GeneratorCallback {
-		(index:number):any;
+	interface GeneratorCallback<T> {
+		(index: number):T;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-	interface Iterator {
-		new(sequence:Sequence):Iterator;
-		current():any;
+	interface Iterator<T> {
+		new (sequence: Sequence<T>):Iterator<T>;
+		current():T;
 		moveNext():boolean;
 	}
 
-	interface GeneratedSequence extends Sequence {
-		new(generatorFn:GeneratorCallback, length:number):GeneratedSequence;
+	interface GeneratedSequence<T> extends Sequence<T> {
+		new(generatorFn: GeneratorCallback<T>, length: number):GeneratedSequence<T>;
 		length():number;
 	}
 
-	interface AsyncSequence extends SequenceBase {
-		each(callback:ValueCallback):AsyncHandle;
+	interface AsyncSequence<T> extends SequenceBase<T> {
+		each(callback: ValueCallback<T>):AsyncHandle<T>;
 	}
 
-	interface AsyncHandle {
+	interface AsyncHandle<T> {
 		cancel():void;
-		onComplete(callback:Callback):void;
-		onError(callback:ErrorCallback):void;
+		onComplete(callback: Callback):void;
+		onError(callback: ErrorCallback):void;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module Sequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface Sequence extends SequenceBase {
-		each(eachFn:ValueCallback):Sequence;
+	interface Sequence<T> extends SequenceBase<T> {
+		each(eachFn: ValueCallback<T>):Sequence<T>;
 	}
 
-	interface SequenceBase extends SequenceBaser {
+	interface SequenceBase<T> extends SequenceBaser<T> {
 		first():any;
-		first(count:number):Sequence;
-		indexOf(value:any, startIndex?:number):Sequence;
+		first(count: number):Sequence<T>;
+		indexOf(value: any, startIndex?: number):Sequence<T>;
 
 		last():any;
-		last(count:number):Sequence;
-		lastIndexOf(value:any):Sequence;
+		last(count: number):Sequence<T>;
+		lastIndexOf(value: any):Sequence<T>;
 
-		reverse():Sequence;
+		reverse():Sequence<T>;
 	}
 
-	interface SequenceBaser {
+	interface SequenceBaser<T> {
 		// TODO improve define() (needs ugly overload)
-		async(interval:number):AsyncSequence;
-		chunk(size:number):Sequence;
-		compact():Sequence;
-		concat(var_args:any[]):Sequence;
-		consecutive(length:number):Sequence;
-		contains(value:any):boolean;
-		countBy(propertyName:string):Sequence;
-		countBy(keyFn:GetKeyCallback):Sequence;
-		dropWhile(predicateFn:TestCallback):Sequence;
-		every(predicateFn:TestCallback):boolean;
-		filter(predicateFn:TestCallback):Sequence;
-		find(predicateFn:TestCallback):Sequence;
-		findWhere(properties:Object):Sequence;
+		async(interval: number):AsyncSequence<T>;
+		chunk(size: number):Sequence<T>;
+		compact():Sequence<T>;
+		concat(var_args: T[]):Sequence<T>;
+		consecutive(length: number):Sequence<T>;
+		contains(value: T):boolean;
+		countBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		countBy(propertyName: string): ObjectLikeSequence<T>;
+		dropWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		every(predicateFn: TestCallback<T>): boolean;
+		filter(predicateFn: TestCallback<T>): Sequence<T>;
+		find(predicateFn: TestCallback<T>): Sequence<T>;
+		findWhere(properties: Object): Sequence<T>;
 
-		flatten():Sequence;
-		groupBy(keyFn:GetKeyCallback):ObjectLikeSequence;
-		initial(count?:number):Sequence;
-		intersection(var_args:any[]):Sequence;
-		invoke(methodName:string):Sequence;
-		isEmpty():boolean;
-		join(delimiter?:string):string;
-		map(mapFn:MapCallback):Sequence;
-		max(valueFn?:NumberCallback):any;
-		min(valueFn?:NumberCallback):any;
-		pluck(propertyName:string):Sequence;
-		reduce(aggregatorFn:MemoCallback, memo?:any):any;
-		reduceRight(aggregatorFn:MemoCallback, memo:any):any;
-		reject(predicateFn:TestCallback):Sequence;
-		rest(count?:number):Sequence;
-		shuffle():Sequence;
-		some(predicateFn?:TestCallback):boolean;
-		sortBy(sortFn:NumberCallback):Sequence;
-		sortedIndex(value:any):Sequence;
-		sum(valueFn?:NumberCallback):Sequence;
-		takeWhile(predicateFn:TestCallback):Sequence;
-		union(var_args:any[]):Sequence;
-		uniq():Sequence;
-		where(properties:Object):Sequence;
-		without(var_args:any[]):Sequence;
-		zip(var_args:any[]):Sequence;
+		flatten(): Sequence<T>;
+		groupBy(keyFn: GetKeyCallback<T>): ObjectLikeSequence<T>;
+		initial(count?: number): Sequence<T>;
+		intersection(var_args: T[]): Sequence<T>;
+		invoke(methodName: string): Sequence<T>;
+		isEmpty(): boolean;
+		join(delimiter?: string): string;
+		map<U>(mapFn: MapCallback<T, U>): Sequence<U>;
 
-		toArray():any[];
-		toObject():Object;
+		max(valueFn?: NumberCallback<T>): T;
+		min(valueFn?: NumberCallback<T>): T;
+		pluck(propertyName: string): Sequence<T>;
+		reduce<U>(aggregatorFn: MemoCallback<T, U>, memo?: U): U;
+		reduceRight<U>(aggregatorFn: MemoCallback<T, U>, memo: U): U;
+		reject(predicateFn: TestCallback<T>): Sequence<T>;
+		rest(count?: number): Sequence<T>;
+		shuffle(): Sequence<T>;
+		some(predicateFn?: TestCallback<T>): boolean;
+		sortBy(sortFn: NumberCallback<T>): Sequence<T>;
+		sortedIndex(value: T): Sequence<T>;
+		sum(valueFn?: NumberCallback<T>): Sequence<T>;
+		takeWhile(predicateFn: TestCallback<T>): Sequence<T>;
+		union(var_args: T[]): Sequence<T>;
+		uniq(): Sequence<T>;
+		where(properties: Object): Sequence<T>;
+		without(var_args: T[]): Sequence<T>;
+		zip(var_args: T[]): Sequence<T>;
+
+		toArray(): T[];
+		toObject(): Object;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module ArrayLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface ArrayLikeSequence extends Sequence {
+	interface ArrayLikeSequence<T> extends Sequence<T> {
 		// define()X;
-		concat():ArrayLikeSequence;
-		first(count?:number):ArrayLikeSequence;
-		get(index:number):any;
-		length():number;
-		map(mapFn:MapCallback):ArrayLikeSequence;
-		pop():ArrayLikeSequence;
-		rest(count?:number):ArrayLikeSequence;
-		reverse():ArrayLikeSequence;
-		shift():ArrayLikeSequence;
-		slice(begin:number, end?:number):ArrayLikeSequence;
+		concat(): ArrayLikeSequence<T>;
+		first(count?: number): ArrayLikeSequence<T>;
+		get(index: number): T;
+		length(): number;
+		map<U>(mapFn: MapCallback<T, U>): ArrayLikeSequence<U>;
+		pop(): ArrayLikeSequence<T>;
+		rest(count?: number): ArrayLikeSequence<T>;
+		reverse(): ArrayLikeSequence<T>;
+		shift(): ArrayLikeSequence<T>;
+		slice(begin: number, end?: number): ArrayLikeSequence<T>;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module ObjectLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface ObjectLikeSequence extends Sequence {
-		assign(other:Object):ObjectLikeSequence;
+	interface ObjectLikeSequence<T> extends Sequence<T> {
+		assign(other: Object): ObjectLikeSequence<T>;
 		// throws error
-		//async():X;
-		defaults(defaults:Object):ObjectLikeSequence;
-		functions():Sequence;
-		get(property:string):ObjectLikeSequence;
-		invert():ObjectLikeSequence;
-		keys():Sequence;
-		omit(properties:string[]):ObjectLikeSequence;
-		pairs():Sequence;
-		pick(properties:string[]):ObjectLikeSequence;
-		toArray():any[];
-		toObject():Object;
-		values():Sequence;
+		//async(): X;
+		defaults(defaults: Object): ObjectLikeSequence<T>;
+		functions(): Sequence<T>;
+		get(property: string): ObjectLikeSequence<T>;
+		invert(): ObjectLikeSequence<T>;
+		keys(): Sequence<string>;
+		omit(properties: string[]): ObjectLikeSequence<T>;
+		pairs(): Sequence<T>;
+		pick(properties: string[]): ObjectLikeSequence<T>;
+		toArray(): T[];
+		toObject(): Object;
+		values(): Sequence<T>;
 	}
 
 	// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 	module StringLikeSequence {
-		function define(methodName:string[], overrides:Object):Function;
+		function define(methodName: string[], overrides: Object): Function;
 	}
 
-	interface StringLikeSequence extends SequenceBaser {
-		charAt(index:number):string;
-		charCodeAt(index:number):number;
-		contains(value:string):boolean;
-		endsWith(suffix:string):boolean;
+	interface StringLikeSequence extends SequenceBaser<string> {
+		charAt(index: number): string;
+		charCodeAt(index: number): number;
+		contains(value: string): boolean;
+		endsWith(suffix: string): boolean;
 
-		first():string;
-		first(count:number):StringLikeSequence;
+		first(): string;
+		first(count: number): StringLikeSequence;
 
-		indexOf(substring:string, startIndex?:number):number;
+		indexOf(substring: string, startIndex?: number): number;
 
-		last():string;
-		last(count:number):StringLikeSequence;
+		last(): string;
+		last(count: number): StringLikeSequence;
 
-		lastIndexOf(substring:string, startIndex?:number):number;
-		mapString(mapFn:MapStringCallback):StringLikeSequence;
-		match(pattern:RegExp):StringLikeSequence;
-		reverse():StringLikeSequence;
+		lastIndexOf(substring: string, startIndex?: number): number;
+		mapString(mapFn: MapStringCallback): StringLikeSequence;
+		match(pattern: RegExp): StringLikeSequence;
+		reverse(): StringLikeSequence;
 
-		split(delimiter:string):Sequence;
-		split(delimiter:RegExp):Sequence;
+		split(delimiter: string): StringLikeSequence;
+		split(delimiter: RegExp): StringLikeSequence;
 
-		startsWith(prefix:string):boolean;
-		substring(start:number, stop?:number):StringLikeSequence;
-		toLowerCase():StringLikeSequence;
-		toUpperCase():StringLikeSequence;
+		startsWith(prefix: string): boolean;
+		substring(start: number, stop?: number): StringLikeSequence;
+		toLowerCase(): StringLikeSequence;
+		toUpperCase(): StringLikeSequence;
 	}
 }
 
-declare var Lazy:LazyJS.LazyStatic;
+declare var Lazy: LazyJS.LazyStatic;
 
 declare module 'lazy.js' {
 export = Lazy;