diff --git a/streamjs/README.md b/streamjs/README.md
new file mode 100644
index 0000000000..400e3bc412
--- /dev/null
+++ b/streamjs/README.md
@@ -0,0 +1,12 @@
+# StreamJS Type Definitions
+
+Note: this definition file is not for the StreamJS library available at http://streamjs.org but the one at
+http://winterbe.github.io/streamjs/ .
+
+Unsupported StreamJS function / method signatures:
+ * `Stream(collection)` (but `Stream.from(collection)` works)
+ * `Stream(string)` (but `Stream.from(string)` works)
+ * `Stream.empty()` 
+ * `map(path)`
+ * `flatMap(path)`
+ * `Optional.empty()`
diff --git a/streamjs/streamjs-tests.ts b/streamjs/streamjs-tests.ts
new file mode 100644
index 0000000000..f911c8f522
--- /dev/null
+++ b/streamjs/streamjs-tests.ts
@@ -0,0 +1,152 @@
+/// <reference path="streamjs.d.ts" />
+
+var numStream: Stream<number>;
+numStream = Stream.of(1, 2, 3);
+numStream = Stream.range(1, 5);
+numStream = Stream.rangeClosed(1, 5);
+numStream = Stream.from([1, 2, 3]);
+Stream.generate(function() {
+	return 1;
+});
+Stream.generate(() => 1);
+
+numStream = Stream.iterate(1, (n) => n * 2);
+
+var comparator = (s1: string, s2: string) => 0;
+
+numStream = numStream.filter(n => n % 2 == 0);
+var strStream = numStream
+					.dropWhile((n: number) => n % 2 == 0)
+					.map(n => "number " + n)
+					.dropWhile(/^$/)
+					.limit(100)
+					.sorted()
+					.sort()
+					.sort("propName")
+					.sorted(comparator)
+					.sort(comparator)
+					.sorted("propName")
+					.shuffle()
+					.reverse()
+					.distinct()
+					.skip(5)
+					.peek(s => console.log(s))
+					.takeWhile(s => s.length < 5)
+					.takeWhile(/^aa.*$/)
+					.slice(5, 2)
+					;
+strStream = Stream.from("foobar");
+var strArray = strStream.toArray();
+strArray = strStream.toList();
+strStream.each(s => console.log(s));
+strStream.filter(/^$/);
+strStream.forEach(s => console.log(s));
+var opt: Stream.Optional<string> = strStream.findFirst();
+opt = strStream.findAny();
+opt = strStream.max();
+opt = strStream.max((s1, s2) => 0);
+opt = strStream.min();
+opt = strStream.min((s1, s2) => 0);
+
+var sum = numStream.sum();
+sum = numStream.sum("foo");
+var avg = numStream.average();
+avg = numStream.average("foo");
+avg = numStream.avg();
+avg = numStream.avg("foo");
+
+var count = numStream.count();
+count = numStream.size();
+
+var allMatch: boolean = numStream.allMatch(n => true);
+allMatch = strStream.allMatch(/^$/);
+
+var anyMatch: boolean = numStream.anyMatch(n => false);
+anyMatch = strStream.anyMatch(/^$/);
+
+var noneMatch: boolean = numStream.noneMatch(n => false);
+noneMatch = strStream.noneMatch(/^$/);
+
+sum = numStream.reduce(0, (n1, n2) => n1 + n2);
+opt = strStream.reduce((s1, s2) => s1 + s2);
+
+class MyList {
+	elems: any[];
+	name: string
+}
+
+var elems: any[];
+
+var myStream: Stream<MyList> = Stream.from([new MyList, new MyList]);
+elems = myStream
+	.flatMap(list => list.elems)
+	.toArray();
+
+myStream = myStream.takeWhile({name: "foo"});
+myStream = myStream.dropWhile({name: "foo"});
+myStream = myStream.filter({name: "foo"});
+var myResult = myStream.min("name");
+myResult = myStream.max("name");
+var match: boolean = myStream.allMatch({name: "foo"});
+match = myStream.anyMatch({name: "foo"});
+
+numStream.collect({
+	supplier: () => 0,
+	accumulator: (n1, n2) => n1 + n2,
+	finisher: n => n
+});
+
+var groupingResult = myStream.groupBy(lst => lst.name);
+var elems = groupingResult["hello"].elems;
+groupingResult = myStream.groupingBy(lst => lst.name);
+groupingResult = myStream.groupBy("name");
+groupingResult = myStream.groupingBy("name");
+
+var mappingResult = myStream.toMap((lst) => lst.name, (e1: MyList, e2: MyList) => e2);
+var aMappingResult: MyList = mappingResult["a"];
+
+mappingResult = myStream.toMap("a");
+
+myStream.toMap(lst => lst.name);
+
+mappingResult = myStream.indexBy(lst => lst.name, (e1, e2) => e2);
+
+var partitionedNums: number[][] = numStream.partitioningBy(n => n % 2 == 0);
+partitionedNums = numStream.partitionBy(n => n % 2 == 0);
+
+var partitionedStrings : string[][] = strStream.partitionBy(/^a$/);
+partitionedStrings = strStream.partitioningBy(/^a$/);
+partitionedStrings = strStream.partitioningBy(5);
+partitionedStrings = strStream.partitionBy(5);
+
+var partitionedList: MyList[][] = myStream.partitionBy({name : "foo"});
+partitionedList = myStream.partitioningBy({name : "foo"});
+
+var s: string = numStream.joining();
+s = numStream.join();
+s = numStream.joining(", ");
+s = numStream.join(", ");
+s = numStream.joining({prefix: "{", delimiter: ", ", suffix: "}"});
+s = numStream.join({prefix: "{", delimiter: ", ", suffix: "}"});
+
+
+var iter = numStream.iterator();
+var n: number = iter.next();
+var done: boolean = iter.done;
+
+var optNum: Stream.Optional<number> = Stream.Optional.of(2);
+optNum = Stream.Optional.ofNullable(null);
+
+var optStr: Stream.Optional<String> = optNum.filter(n => n % 2 == 0)
+	.map(n => "number" + n)
+	.flatMap(n => Stream.Optional.of(n + 2))
+	;
+	
+var isPresent: boolean = optNum.isPresent();
+var num: number = optNum.get();
+optNum.ifPresent(n => console.log(n));
+var def: number = optNum.orElse(2);
+def = optNum.orElseGet(() => 3);
+def = optNum.orElseThrow("something went wrong");
+
+
diff --git a/streamjs/streamjs.d.ts b/streamjs/streamjs.d.ts
new file mode 100644
index 0000000000..59d8019f39
--- /dev/null
+++ b/streamjs/streamjs.d.ts
@@ -0,0 +1,165 @@
+// Type definitions for streamjs 1.5.0
+// Project: http://winterbe.github.io/streamjs/
+// Definitions by: Bence Eros <https://github.com/erosb>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare class Stream<T> {
+	static from <T> (elems: T[]): Stream<T>;
+	static from(str: string): Stream<string>;
+	static of<T>(...elems: T[]): Stream<T>;
+	static range (startInclusive: number, endExclusive: number): Stream<number>;
+	static rangeClosed (startInclusive: number, endInclusive: number): Stream<number>;
+	static generate <T> (supplier: Stream.Supplier<T>): Stream<T>;
+	static iterate<T>(seed: T, fn: Stream.Function<T, T>): Stream<T>;
+	
+	anyMatch(predicate: Stream.Predicate<T>): boolean;
+	anyMatch(regexp: RegExp): boolean;
+	anyMatch(sample: Stream.Sample): boolean;
+	allMatch(predicate: Stream.Predicate<T>): boolean;
+	allMatch(regexp: RegExp): boolean;
+	allMatch(sample: Stream.Sample): boolean;
+	average(): number;
+	average(path: string): number;
+	avg(): number;
+	avg(path: string): number;
+	collect(collector: Stream.Collector<T>): T;
+	count(): number;
+	distinct(): Stream<T>;
+	dropWhile(predicate: Stream.Predicate<T>): Stream<T>;
+	dropWhile(regexp: RegExp): Stream<string>;
+	dropWhile(sample: Stream.Sample): Stream<T>;
+	each(consumer: Stream.Consumer<T>): void;
+	filter(predicate: Stream.Predicate<T>): Stream<T>;
+	filter(regexp: RegExp): Stream<string>;
+	filter(sample: Stream.Sample): Stream<T>;
+	findAny(): Stream.Optional<T>;
+	findFirst(): Stream.Optional<T>;
+	forEach(consumer: Stream.Consumer<T>): void;
+	
+	groupBy(mapper: Stream.Function<T, string>): Stream.GroupingResult<T>;
+	groupBy(path: string): Stream.GroupingResult<T>;
+	groupingBy(mapper: Stream.Function<T, string>): Stream.GroupingResult<T>;
+	groupingBy(path: string): Stream.GroupingResult<T>;
+	indexBy(keyMapper: Stream.Function<T, string>, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
+	map <U> (mapper: Stream.Function<T, U>): Stream<U>;
+	max(): Stream.Optional<T>;
+	max(comparator: Stream.Comparator<T>): Stream.Optional<T>;
+	max(path: string): Stream.Optional<T>;
+	min(): Stream.Optional<T>;
+	min(comparator: Stream.Comparator<T>): Stream.Optional<T>;
+	min(path: string): Stream.Optional<T>;
+	noneMatch(predicate: (elem: T) => boolean): boolean;
+	noneMatch(regexp: RegExp): boolean;
+	flatMap <U> (mapper: Stream.Function<T, U[]>): Stream<U>;
+	iterator(): Stream.Iterator<T>;
+	joining(): string;
+	joining(delimiter: string): string;
+	joining(options: Stream.JoinOptions): string;
+	join(): string;
+	join(delimiter: string): string;
+	join(options: Stream.JoinOptions): string;
+	limit(limit: number): Stream<T>;
+	partitioningBy(predicate: Stream.Predicate<T>): T[][];
+	partitionBy(predicate: Stream.Predicate<T>): T[][];
+	partitionBy(sample: Stream.Sample): T[][];
+	partitioningBy(regexp: RegExp): T[][];
+	partitionBy(regexp: RegExp): T[][];
+	partitioningBy(size: number): T[][];
+	partitionBy(size: number): T[][];
+	partitioningBy(sample: Stream.Sample): T[][];
+	peek(consumer: Stream.Consumer<T>): Stream<T>;
+	reduce(identity: T, accumulator: Stream.Accumulator<T>): T;
+	reduce(accumulator: Stream.Accumulator<T>): Stream.Optional<T>;
+	reverse(): Stream<T>;
+	size(): number;
+	sorted(): Stream<T>;
+	sorted(comparator: Stream.Comparator<T>): Stream<T>;
+	sorted(path: string): Stream<T>;
+	sort(): Stream<T>;
+	sort(comparator: Stream.Comparator<T>): Stream<T>;
+	sort(path: string): Stream<T>;
+	shuffle(): Stream<T>;
+	skip(n: number): Stream<T>;
+	slice(begin: number, end: number): Stream<T>;
+	sum(): number;
+	sum(path: string): number;
+	takeWhile(predicate: Stream.Predicate<T>): Stream<T>;
+	takeWhile(regexp: RegExp): Stream<string>;
+	takeWhile(sample: Stream.Sample): Stream<T>;
+	toArray(): T[];
+	toList(): T[];
+	toMap(keyMapper: Stream.Function<T, string>, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
+	toMap(path: string, mergeFunction?: Stream.Accumulator<T>): Stream.Map<T>;
+}
+
+declare module Stream {
+
+	export interface Map<T> {
+		[index: string]: T
+	}
+	
+
+	export interface Sample {
+		[index: string]: any
+	}
+
+	export interface Accumulator<T> {
+		(e1: T, e2: T): T;
+	}
+	
+	export interface Collector<T> {
+		supplier: Supplier<T>;
+		accumulator: Stream.Accumulator<T>;
+		finisher: Function<T, T>;
+	}
+
+	export interface Comparator<T> {
+		(e1: T, e2: T): number
+	}
+	
+	export interface Consumer<T> {
+		(elem: T): void;
+	}
+
+	export interface Function<T, U> {
+		(elem: T): U;
+	}
+	
+	export interface GroupingResult<T> {
+		[index: string]: T
+	}
+	
+	export interface Iterator<T> {
+		next(): T;
+		done: boolean;
+	}
+	
+	export interface JoinOptions {
+		prefix: string;
+		delimiter: string;
+		suffix: string;
+	}
+
+	export interface Predicate<T> {
+		(elem: T): boolean;
+	}
+	
+	export interface Supplier<T> {
+		(): T
+	}
+
+	export class Optional<T> {
+		static of<T>(elem: T): Optional<T>;
+		static ofNullable<T>(elem: T): Optional<T>;
+		
+		filter(predicate: (elem: T) => boolean): Optional<T>;
+		map<U>(mapper: (elem: T) => U): Optional<U>;
+		flatMap<U>(mapper: (elem: T) => Stream.Optional<U>): Optional<U>;
+		isPresent(): boolean;
+		get(): T;
+		ifPresent(consumer: (elem: T) => void): void;
+		orElse(other: T): T;
+		orElseGet(supplier: Stream.Supplier<T>): T;
+		orElseThrow(error: any): T;
+	}
+}