From 273f1453129c1bc93859e15254cf9bc6ce9d1363 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:03:48 +0200
Subject: [PATCH 1/6] Add Steed typings

---
 package.json         |   2 +-
 steed/index.d.ts     |  56 +++++++
 steed/steed-tests.ts | 353 +++++++++++++++++++++++++++++++++++++++++++
 steed/tsconfig.json  |  20 +++
 tslint-common.json   |  37 +++++
 tslint.json          |  14 +-
 6 files changed, 480 insertions(+), 2 deletions(-)
 create mode 100644 steed/index.d.ts
 create mode 100644 steed/steed-tests.ts
 create mode 100644 steed/tsconfig.json
 create mode 100644 tslint-common.json

diff --git a/package.json b/package.json
index a9b9625069..a41b9ddc69 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,6 @@
     "test": "node node_modules/types-publisher/bin/tester/test.js --run-from-definitely-typed --nProcesses 1"
   },
   "devDependencies": {
-    "types-publisher": "Microsoft/types-publisher#production"
+    "": "Microsoft/types-publisher#production"
   }
 }
diff --git a/steed/index.d.ts b/steed/index.d.ts
new file mode 100644
index 0000000000..3bad4d1ab1
--- /dev/null
+++ b/steed/index.d.ts
@@ -0,0 +1,56 @@
+// Type definitions for steed 1.1
+// Project: https://github.com/mcollina/steed#readme
+// Definitions by: Paul Isache <https://github.com/Paul-Isache>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface Dictionary<T> { [key: string]: T }
+interface ErrorCallback<T> { (err?: T): void }
+
+interface SteedResultCallback<T, E> { (err: E, result: T): void }
+interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void }
+interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void }
+
+interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void }
+interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void }
+interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void }
+interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void }
+
+interface SteedQueue<T> {
+    push<E>(task: T, callback?: ErrorCallback<E>): void;
+    push<E>(task: T, callback?: SteedResultCallback<T, E>): void;
+    push<E>(task: T[], callback?: ErrorCallback<E>): void;
+    unshift<E>(task: T, callback?: ErrorCallback<E>): void;
+    unshift<E>(task: T[], callback?: ErrorCallback<E>): void;
+    pause(): void;
+    resume(): void;
+    idle(): boolean;
+    length(): number;
+    kill(): void;
+    concurrency: number;
+    drain: () => any;
+    empty: () => any;
+    saturated: () => any;
+}
+
+interface Steed {
+    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+    series<T, E>(tasks: SteedFunction<T, E>[], callback?: SteedResultArrayCallback<T, E>): void;
+    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+    each<T, E>(arr: T[], iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    each<T, E>(arr: Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    eachSeries: typeof steed.each;
+    map<T, R, E>(arr: T[], iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    map<T, R, E>(arr: Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    mapSeries: typeof steed.map;
+    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>
+}
+
+
+declare const steed: Steed
+
+declare module "steed" {
+    export = steed
+}
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
new file mode 100644
index 0000000000..679c597b08
--- /dev/null
+++ b/steed/steed-tests.ts
@@ -0,0 +1,353 @@
+/// <reference types="node" />
+
+import fs = require("fs");
+import process = require("process");
+
+declare var path: {
+    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+};
+
+function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function callback() { }
+
+steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
+
+
+steed.parallel([
+    function () { },
+    function () { }
+], callback);
+
+steed.series([
+    function () { },
+    function () { }
+]);
+
+var data: any[] = [];
+function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (err, results) {
+    console.log(results);
+});
+
+var openFiles = ['file1', 'file2'];
+
+var saveFile = function (file:string,cb:(err:Error)=>void) { }
+steed.each(openFiles, saveFile, function (err:Error) { });
+steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+
+// Control Flow //
+
+steed.series([
+    function (callback) {
+        callback(undefined, 'one');
+    },
+    function (callback) {
+        callback(undefined, 'two');
+    },
+],
+function (err, results) { });
+
+steed.series<string,Error>([
+    function (callback) {
+        callback(undefined, 'one');
+    },
+    function (callback) {
+        callback(undefined, 'two');
+    },
+],
+function (err, results) { });
+
+steed.series({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.series<number,Error>({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.parallel([
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'one');
+        }, 200);
+    },
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'two');
+        }, 100);
+    },
+],
+function (err, results) { });
+
+steed.parallel<string,Error>([
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'one');
+        }, 200);
+    },
+    function (callback) {
+        setTimeout(function () {
+            callback(undefined, 'two');
+        }, 100);
+    },
+],
+function (err, results) { });
+
+
+steed.parallel({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+function (err, results) { });
+
+steed.parallel<number,Error>({
+    one: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 1);
+        }, 200);
+    },
+    two: function (callback) {
+        setTimeout(function () {
+            callback(undefined, 2);
+        }, 100);
+    },
+},
+    function (err, results) { });
+
+function whileFn(callback: any) {
+    count++;
+    setTimeout(callback, 1000);
+}
+
+function whileTest() { return count < 5; }
+var count = 0;
+
+steed.waterfall([
+    function (callback: any) {
+        callback(null, 'one', 'two');
+    },
+    function (arg1: any, arg2: any, callback: any) {
+        callback(null, 'three');
+    },
+    function (arg1: any, callback: any) {
+        callback(null, 'done');
+    }
+], function (err, result) { });
+
+
+var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+    console.log('hello ' + task.name);
+    callback();
+}, 2);
+
+
+q.drain = function () {
+    console.log('all items have been processed');
+}
+
+q.push({ name: 'foo' });
+
+q.push({ name: 'bar' }, function (err) {
+    console.log('finished processing bar');
+});
+
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+    console.log('finished processing bar');
+});
+
+q.unshift({ name: 'foo' });
+
+q.unshift({ name: 'bar' }, function (err) {
+    console.log('finished processing bar');
+});
+
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+    console.log('finished processing bar');
+});
+
+var qLength : number = q.length();
+var qIsIdle : boolean = q.idle();
+
+q.saturated = function() {
+    console.log('queue is saturated.');
+}
+
+q.empty = function() {
+    console.log('queue is empty.');
+}
+
+q.drain = function() {
+    console.log('queue was drained.');
+}
+
+q.pause();
+q.resume();
+q.kill();
+
+// tests for strongly typed tasks
+var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+    console.log('Task: ' + task);
+    callback();
+}, 1);
+
+q2.push('task1');
+
+q2.push('task2', function (error) {
+    console.log('Finished tasks');
+});
+
+q2.push(['task3', 'task4', 'task5'], function (error) {
+    console.log('Finished tasks');
+});
+
+q2.unshift('task1');
+
+q2.unshift('task2', function (error) {
+    console.log('Finished tasks');
+});
+
+q2.unshift(['task3', 'task4', 'task5'], function (error) {
+    console.log('Finished tasks');
+});
+
+
+var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+    console.log('hello ' + level);
+    callback(null, level+1);
+});
+
+aq.push(1, function (err : Error, newLevel : number) {
+    console.log('finished processing bar' + newLevel);
+});
+
+
+steed.parallel([
+    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback) { }
+],
+function (err:Error,results:Array<string>) {
+    steed.series([
+        function (callback) { },
+        function email_link(callback) { }
+    ]);
+});
+
+steed.parallel([
+    function (callback) {
+        fs.writeFile('testfile1', 'test1', callback);
+    },
+    function (callback) {
+        fs.writeFile('testfile2', 'test2', callback);
+    },
+]);
+
+// each
+
+steed.each<number,Error>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback<Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.each: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("steed.each: done.");
+
+});
+
+steed.eachSeries<number, Error>({
+    "a": 1,
+    "b": 2
+}, function(val: number, next: ErrorCallback<Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.eachSeries: ${val}`);
+
+        next();
+
+    }, 500);
+
+}, function(err?: Error): void {
+
+    console.log("steed.eachSeries: done.");
+
+});
+
+// map
+
+steed.map<number, string, Error>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: SteedResultCallback<string, Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.map: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("steed.map: done with results", results);
+
+});
+
+steed.mapSeries<number, string, Error>({
+    "a": 1,
+    "b": 2,
+    "c": 3
+}, function(val: number, next: SteedResultCallback<string, Error>): void {
+
+    setTimeout(function(): void {
+
+        console.log(`steed.mapSeries: ${val}`);
+
+        next(undefined as any, val.toString());
+
+    }, 500);
+
+}, function(err: Error, results: string[]): void {
+
+    console.log("steed.mapSeries: done with results", results);
+
+});
\ No newline at end of file
diff --git a/steed/tsconfig.json b/steed/tsconfig.json
new file mode 100644
index 0000000000..ec8377c527
--- /dev/null
+++ b/steed/tsconfig.json
@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "target": "es6",
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "steed-tests.ts"
+    ]
+}
diff --git a/tslint-common.json b/tslint-common.json
new file mode 100644
index 0000000000..94ad064cab
--- /dev/null
+++ b/tslint-common.json
@@ -0,0 +1,37 @@
+{
+	"extends": "tslint:latest",
+	"rulesDirectory": [
+		"bin/tslint"
+	],
+	"rules": {
+		// Custom rules
+		"dt-header": true,
+		"export-just-namespace": true,
+		"forbidden-types": true,
+		"no-dead-reference": true,
+		"no-parent-references": true,
+		"no-public": true,
+		"no-reference-import": true,
+		"no-single-declare-module": true,
+		"unified-signatures": true,
+		"void-return": true,
+
+		"array-type": [true, "array-simple"],
+		"arrow-parens": false,
+		"callable-types": true,
+		"interface-name": [true, "never-prefix"],
+		"interface-over-type-literal": true,
+		"max-classes-per-file": false,
+		"member-access": false,
+		"member-ordering": false,
+		"no-bitwise": false,
+		"no-console": false,
+		"no-empty-interface": true,
+		"no-namespace": false,
+		"object-literal-sort-keys": false,
+		"one-variable-per-declaration": false,
+		"ordered-imports": false,
+		"switch-default": false,
+		"trailing-comma": false
+    }
+}
\ No newline at end of file
diff --git a/tslint.json b/tslint.json
index 6b04ae7f36..7a4e7686db 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1 +1,13 @@
-{ "extends": "./node_modules/types-publisher/tslint-definitions.json" }
\ No newline at end of file
+{
+	"extends": "./tslint-common.json",
+	"rules": {
+		"forin": false,
+		"indent": [true, "tabs"],
+		"max-line-length": [true, 150],
+		"no-var-requires": false,
+		"one-line": false,
+		// https://github.com/palantir/tslint/issues/2001
+		"space-before-function-paren": [true, {"asyncArrow": "always"}],
+		"variable-name": false
+	}
+}
\ No newline at end of file

From 08015645c72a91a940e2368b40e7cceeef2500da Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:07:01 +0200
Subject: [PATCH 2/6] Add Steed typings

---
 tslint-common.json | 37 -------------------------------------
 tslint.json        | 14 +-------------
 2 files changed, 1 insertion(+), 50 deletions(-)
 delete mode 100644 tslint-common.json

diff --git a/tslint-common.json b/tslint-common.json
deleted file mode 100644
index 94ad064cab..0000000000
--- a/tslint-common.json
+++ /dev/null
@@ -1,37 +0,0 @@
-{
-	"extends": "tslint:latest",
-	"rulesDirectory": [
-		"bin/tslint"
-	],
-	"rules": {
-		// Custom rules
-		"dt-header": true,
-		"export-just-namespace": true,
-		"forbidden-types": true,
-		"no-dead-reference": true,
-		"no-parent-references": true,
-		"no-public": true,
-		"no-reference-import": true,
-		"no-single-declare-module": true,
-		"unified-signatures": true,
-		"void-return": true,
-
-		"array-type": [true, "array-simple"],
-		"arrow-parens": false,
-		"callable-types": true,
-		"interface-name": [true, "never-prefix"],
-		"interface-over-type-literal": true,
-		"max-classes-per-file": false,
-		"member-access": false,
-		"member-ordering": false,
-		"no-bitwise": false,
-		"no-console": false,
-		"no-empty-interface": true,
-		"no-namespace": false,
-		"object-literal-sort-keys": false,
-		"one-variable-per-declaration": false,
-		"ordered-imports": false,
-		"switch-default": false,
-		"trailing-comma": false
-    }
-}
\ No newline at end of file
diff --git a/tslint.json b/tslint.json
index 7a4e7686db..6b04ae7f36 100644
--- a/tslint.json
+++ b/tslint.json
@@ -1,13 +1 @@
-{
-	"extends": "./tslint-common.json",
-	"rules": {
-		"forin": false,
-		"indent": [true, "tabs"],
-		"max-line-length": [true, 150],
-		"no-var-requires": false,
-		"one-line": false,
-		// https://github.com/palantir/tslint/issues/2001
-		"space-before-function-paren": [true, {"asyncArrow": "always"}],
-		"variable-name": false
-	}
-}
\ No newline at end of file
+{ "extends": "./node_modules/types-publisher/tslint-definitions.json" }
\ No newline at end of file

From 43e36a1ce921c55227cab6b4535ab6e76f869df2 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Thu, 26 Jan 2017 15:17:38 +0200
Subject: [PATCH 3/6] Add Steed typings

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index a41b9ddc69..a9b9625069 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,6 @@
     "test": "node node_modules/types-publisher/bin/tester/test.js --run-from-definitely-typed --nProcesses 1"
   },
   "devDependencies": {
-    "": "Microsoft/types-publisher#production"
+    "types-publisher": "Microsoft/types-publisher#production"
   }
 }

From 413b64448a9a0554050d27ee9acdb2fd5878c703 Mon Sep 17 00:00:00 2001
From: Bogdan Ursache <bogdan.ursache@thinslices.com>
Date: Thu, 26 Jan 2017 15:47:15 +0200
Subject: [PATCH 4/6] steed - Fix linting errors

---
 steed/index.d.ts     | 40 +++++++++++++++++-----------------------
 steed/steed-tests.ts | 16 ++++++++--------
 2 files changed, 25 insertions(+), 31 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index 3bad4d1ab1..f88669e92c 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,24 +3,21 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T }
-interface ErrorCallback<T> { (err?: T): void }
+interface Dictionary<T> { [key: string]: T; }
+interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void }
+interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void }
+interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
 
 interface SteedQueue<T> {
-    push<E>(task: T, callback?: ErrorCallback<E>): void;
-    push<E>(task: T, callback?: SteedResultCallback<T, E>): void;
-    push<E>(task: T[], callback?: ErrorCallback<E>): void;
-    unshift<E>(task: T, callback?: ErrorCallback<E>): void;
-    unshift<E>(task: T[], callback?: ErrorCallback<E>): void;
+    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
     pause(): void;
     resume(): void;
     idle(): boolean;
@@ -35,22 +32,19 @@ interface SteedQueue<T> {
 interface Steed {
     parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
     parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: SteedFunction<T, E>[], callback?: SteedResultArrayCallback<T, E>): void;
+    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
     series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
     waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[], iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    each<T, E>(arr: Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
     eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[], iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    map<T, R, E>(arr: Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
     mapSeries: typeof steed.map;
     queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>
+    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
 }
 
-
-declare const steed: Steed
+declare const steed: Steed;
 
 declare module "steed" {
-    export = steed
+    export = steed;
 }
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 679c597b08..729e59472f 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -240,14 +240,14 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-    console.log('hello ' + level);
-    callback(null, level+1);
-});
-
-aq.push(1, function (err : Error, newLevel : number) {
-    console.log('finished processing bar' + newLevel);
-});
+// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+//     console.log('hello ' + level);
+//     callback(null, level+1);
+// });
+//
+// aq.push(1, function (err : Error, newLevel : number) {
+//     console.log('finished processing bar' + newLevel);
+// });
 
 
 steed.parallel([

From ba6a418311d7ea62117f9c3317cdcfce8022e318 Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@Pauls-MacBook-Pro-2.local>
Date: Fri, 27 Jan 2017 08:49:48 +0200
Subject: [PATCH 5/6] Steed - declare namespace and modify tests

---
 steed/index.d.ts     |  79 +++++++++++++-------------
 steed/steed-tests.ts | 129 +++++++++++++++++--------------------------
 2 files changed, 92 insertions(+), 116 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index f88669e92c..ba4b199999 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,48 +3,49 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
-interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void; }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+declare namespace steed {
+    interface Dictionary<T> { [key: string]: T; }
+    interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+    interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+    interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+    interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedQueue<T> {
-    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    pause(): void;
-    resume(): void;
-    idle(): boolean;
-    length(): number;
-    kill(): void;
-    concurrency: number;
-    drain: () => any;
-    empty: () => any;
-    saturated: () => any;
+    interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+    interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+    interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+    interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+
+    interface SteedQueue<T> {
+        push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+        unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+        pause(): void;
+        resume(): void;
+        idle(): boolean;
+        length(): number;
+        kill(): void;
+        concurrency: number;
+        drain: () => any;
+        empty: () => any;
+        saturated: () => any;
+    }
+
+    interface Steed {
+        parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+        each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+        eachSeries: typeof steed.each;
+        map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+        mapSeries: typeof steed.map;
+        queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+        queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
+    }
 }
 
-interface Steed {
-    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    mapSeries: typeof steed.map;
-    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
-}
+declare const steed: steed.Steed;
 
-declare const steed: Steed;
-
-declare module "steed" {
-    export = steed;
-}
+export = steed;
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 729e59472f..685654cc52 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -1,19 +1,14 @@
 /// <reference types="node" />
 
-import fs = require("fs");
-import process = require("process");
+import steed = require('steed')
 
 declare var path: {
-    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+    exists: (path: string, callback?: (error: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (error: Error, res: boolean) => void) { }
 function callback() { }
 
-steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-
-
 steed.parallel([
     function () { },
     function () { }
@@ -25,16 +20,16 @@ steed.series([
 ]);
 
 var data: any[] = [];
-function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
-steed.map(data, steedProcess, function (err, results) {
+function steedProcess(item: any, callback: (error: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (error, results) {
     console.log(results);
 });
 
 var openFiles = ['file1', 'file2'];
 
-var saveFile = function (file:string,cb:(err:Error)=>void) { }
-steed.each(openFiles, saveFile, function (err:Error) { });
-steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+var saveFile = function (file: string, cb: (error: Error) => void) { }
+steed.each(openFiles, saveFile, function (error: Error) { });
+steed.eachSeries(openFiles, saveFile, function (error: Error) { });
 
 // Control Flow //
 
@@ -46,9 +41,9 @@ steed.series([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<string,Error>([
+steed.series<string, Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -56,7 +51,7 @@ steed.series<string,Error>([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 steed.series({
     one: function (callback) {
@@ -70,9 +65,9 @@ steed.series({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<number,Error>({
+steed.series<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -84,7 +79,7 @@ steed.series<number,Error>({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
 steed.parallel([
     function (callback) {
@@ -98,9 +93,9 @@ steed.parallel([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<string,Error>([
+steed.parallel<string, Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -112,7 +107,7 @@ steed.parallel<string,Error>([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 
 steed.parallel({
@@ -127,9 +122,9 @@ steed.parallel({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<number,Error>({
+steed.parallel<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -141,7 +136,7 @@ steed.parallel<number,Error>({
         }, 100);
     },
 },
-    function (err, results) { });
+    function (error, results) { });
 
 function whileFn(callback: any) {
     count++;
@@ -161,10 +156,10 @@ steed.waterfall([
     function (arg1: any, callback: any) {
         callback(null, 'done');
     }
-], function (err, result) { });
+], function (error, result) { });
 
 
-var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+var q = steed.queue<any, Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -180,7 +175,7 @@ q.push({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
@@ -190,22 +185,22 @@ q.unshift({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
-var qLength : number = q.length();
-var qIsIdle : boolean = q.idle();
+var qLength: number = q.length();
+var qIsIdle: boolean = q.idle();
 
-q.saturated = function() {
+q.saturated = function () {
     console.log('queue is saturated.');
 }
 
-q.empty = function() {
+q.empty = function () {
     console.log('queue is empty.');
 }
 
-q.drain = function() {
+q.drain = function () {
     console.log('queue was drained.');
 }
 
@@ -214,7 +209,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = steed.queue<string, Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -225,7 +220,7 @@ q2.push('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.push(['task3', 'task4', 'task5'], function (error) {
+q2.push(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
@@ -235,49 +230,29 @@ q2.unshift('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.unshift(['task3', 'task4', 'task5'], function (error) {
+q2.unshift(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
-
-// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-//     console.log('hello ' + level);
-//     callback(null, level+1);
-// });
-//
-// aq.push(1, function (err : Error, newLevel : number) {
-//     console.log('finished processing bar' + newLevel);
-// });
-
-
 steed.parallel([
-    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback: (error: Error, val: string) => void) { },
     function (callback) { }
 ],
-function (err:Error,results:Array<string>) {
-    steed.series([
-        function (callback) { },
-        function email_link(callback) { }
-    ]);
-});
-
-steed.parallel([
-    function (callback) {
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function (callback) {
-        fs.writeFile('testfile2', 'test2', callback);
-    },
-]);
+    function (error: Error, results: Array<string>) {
+        steed.series([
+            function (callback) { },
+            function email_link(callback) { }
+        ]);
+    });
 
 // each
 
-steed.each<number,Error>({
+steed.each<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.each: ${val}`);
 
@@ -285,7 +260,7 @@ steed.each<number,Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.each: done.");
 
@@ -294,9 +269,9 @@ steed.each<number,Error>({
 steed.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.eachSeries: ${val}`);
 
@@ -304,7 +279,7 @@ steed.eachSeries<number, Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.eachSeries: done.");
 
@@ -316,9 +291,9 @@ steed.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.map: ${val}`);
 
@@ -326,7 +301,7 @@ steed.map<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.map: done with results", results);
 
@@ -336,9 +311,9 @@ steed.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.mapSeries: ${val}`);
 
@@ -346,7 +321,7 @@ steed.mapSeries<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.mapSeries: done with results", results);
 

From 1043ffe71c4cdea7f0a0e97f022e70c018e1e01f Mon Sep 17 00:00:00 2001
From: Paul Isache <paul@isache.com>
Date: Fri, 27 Jan 2017 08:49:48 +0200
Subject: [PATCH 6/6] Steed - declare namespace and modify tests

---
 steed/index.d.ts     |  79 +++++++++++++-------------
 steed/steed-tests.ts | 129 +++++++++++++++++--------------------------
 2 files changed, 92 insertions(+), 116 deletions(-)

diff --git a/steed/index.d.ts b/steed/index.d.ts
index f88669e92c..ba4b199999 100644
--- a/steed/index.d.ts
+++ b/steed/index.d.ts
@@ -3,48 +3,49 @@
 // Definitions by: Paul Isache <https://github.com/Paul-Isache>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-interface Dictionary<T> { [key: string]: T; }
-interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedResultCallback<T, E> { (err: E, result: T): void; }
-interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+declare namespace steed {
+    interface Dictionary<T> { [key: string]: T; }
+    interface ErrorCallback<T> { (err?: T): void; }
 
-interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
-interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+    interface SteedResultCallback<T, E> { (err: E, result: T): void; }
+    interface SteedResultArrayCallback<T, E> { (err: E, results: T[]): void; }
+    interface SteedResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
 
-interface SteedQueue<T> {
-    push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    pause(): void;
-    resume(): void;
-    idle(): boolean;
-    length(): number;
-    kill(): void;
-    concurrency: number;
-    drain: () => any;
-    empty: () => any;
-    saturated: () => any;
+    interface SteedWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
+    interface SteedIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
+    interface SteedResultIterator<T, R, E> { (item: T, callback: SteedResultCallback<R, E>): void; }
+    interface SteedFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
+
+    interface SteedQueue<T> {
+        push<E>(task: T | T[], callback?: ErrorCallback<E> | SteedResultCallback<T, E>): void;
+        unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+        pause(): void;
+        resume(): void;
+        idle(): boolean;
+        length(): number;
+        kill(): void;
+        concurrency: number;
+        drain: () => any;
+        empty: () => any;
+        saturated: () => any;
+    }
+
+    interface Steed {
+        parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
+        series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
+        waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
+        each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
+        eachSeries: typeof steed.each;
+        map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
+        mapSeries: typeof steed.map;
+        queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
+        queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
+    }
 }
 
-interface Steed {
-    parallel<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    parallel<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    series<T, E>(tasks: Array<SteedFunction<T, E>>, callback?: SteedResultArrayCallback<T, E>): void;
-    series<T, E>(tasks: Dictionary<SteedFunction<T, E>>, callback?: SteedResultObjectCallback<T, E>): void;
-    waterfall<T, E>(tasks: Function[], callback?: SteedResultCallback<T, E>): void;
-    each<T, E>(arr: T[] | Dictionary<T>, iterator: SteedIterator<T, E>, callback?: ErrorCallback<E>): void;
-    eachSeries: typeof steed.each;
-    map<T, R, E>(arr: T[] | Dictionary<T>, iterator: SteedResultIterator<T, R, E>, callback?: SteedResultArrayCallback<R, E>): void;
-    mapSeries: typeof steed.map;
-    queue<T, E>(worker: SteedWorker<T, E>, concurrency?: number): SteedQueue<T>;
-    queue<T, R, E>(worker: SteedResultIterator<T, R, E>, concurrency?: number): SteedQueue<T>;
-}
+declare const steed: steed.Steed;
 
-declare const steed: Steed;
-
-declare module "steed" {
-    export = steed;
-}
+export = steed;
diff --git a/steed/steed-tests.ts b/steed/steed-tests.ts
index 729e59472f..685654cc52 100644
--- a/steed/steed-tests.ts
+++ b/steed/steed-tests.ts
@@ -1,19 +1,14 @@
 /// <reference types="node" />
 
-import fs = require("fs");
-import process = require("process");
+import steed = require('steed')
 
 declare var path: {
-    exists: (path: string, callback?: (err: Error, exists: boolean) => any) => void;
+    exists: (path: string, callback?: (error: Error, exists: boolean) => any) => void;
 };
 
-function funcStringCbErrBoolean(v:string, cb:(err:Error,res:boolean) => void) {}
+function funcStringCbErrBoolean(v: string, cb: (error: Error, res: boolean) => void) { }
 function callback() { }
 
-steed.map(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-steed.mapSeries(['file1', 'file2', 'file3'], fs.stat, function (err:Error, results:Array<fs.Stats>) { });
-
-
 steed.parallel([
     function () { },
     function () { }
@@ -25,16 +20,16 @@ steed.series([
 ]);
 
 var data: any[] = [];
-function steedProcess(item: any, callback: (err: Error, result: any) => void) { }
-steed.map(data, steedProcess, function (err, results) {
+function steedProcess(item: any, callback: (error: Error, result: any) => void) { }
+steed.map(data, steedProcess, function (error, results) {
     console.log(results);
 });
 
 var openFiles = ['file1', 'file2'];
 
-var saveFile = function (file:string,cb:(err:Error)=>void) { }
-steed.each(openFiles, saveFile, function (err:Error) { });
-steed.eachSeries(openFiles, saveFile, function (err:Error) { });
+var saveFile = function (file: string, cb: (error: Error) => void) { }
+steed.each(openFiles, saveFile, function (error: Error) { });
+steed.eachSeries(openFiles, saveFile, function (error: Error) { });
 
 // Control Flow //
 
@@ -46,9 +41,9 @@ steed.series([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<string,Error>([
+steed.series<string, Error>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -56,7 +51,7 @@ steed.series<string,Error>([
         callback(undefined, 'two');
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 steed.series({
     one: function (callback) {
@@ -70,9 +65,9 @@ steed.series({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.series<number,Error>({
+steed.series<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -84,7 +79,7 @@ steed.series<number,Error>({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
 steed.parallel([
     function (callback) {
@@ -98,9 +93,9 @@ steed.parallel([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<string,Error>([
+steed.parallel<string, Error>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -112,7 +107,7 @@ steed.parallel<string,Error>([
         }, 100);
     },
 ],
-function (err, results) { });
+    function (error, results) { });
 
 
 steed.parallel({
@@ -127,9 +122,9 @@ steed.parallel({
         }, 100);
     },
 },
-function (err, results) { });
+    function (error, results) { });
 
-steed.parallel<number,Error>({
+steed.parallel<number, Error>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -141,7 +136,7 @@ steed.parallel<number,Error>({
         }, 100);
     },
 },
-    function (err, results) { });
+    function (error, results) { });
 
 function whileFn(callback: any) {
     count++;
@@ -161,10 +156,10 @@ steed.waterfall([
     function (arg1: any, callback: any) {
         callback(null, 'done');
     }
-], function (err, result) { });
+], function (error, result) { });
 
 
-var q = steed.queue<any,Error>(function (task: any, callback: () => void) {
+var q = steed.queue<any, Error>(function (task: any, callback: () => void) {
     console.log('hello ' + task.name);
     callback();
 }, 2);
@@ -180,7 +175,7 @@ q.push({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
@@ -190,22 +185,22 @@ q.unshift({ name: 'bar' }, function (err) {
     console.log('finished processing bar');
 });
 
-q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
+q.unshift([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (error: Error) {
     console.log('finished processing bar');
 });
 
-var qLength : number = q.length();
-var qIsIdle : boolean = q.idle();
+var qLength: number = q.length();
+var qIsIdle: boolean = q.idle();
 
-q.saturated = function() {
+q.saturated = function () {
     console.log('queue is saturated.');
 }
 
-q.empty = function() {
+q.empty = function () {
     console.log('queue is empty.');
 }
 
-q.drain = function() {
+q.drain = function () {
     console.log('queue was drained.');
 }
 
@@ -214,7 +209,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = steed.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = steed.queue<string, Error>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -225,7 +220,7 @@ q2.push('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.push(['task3', 'task4', 'task5'], function (error) {
+q2.push(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
@@ -235,49 +230,29 @@ q2.unshift('task2', function (error) {
     console.log('Finished tasks');
 });
 
-q2.unshift(['task3', 'task4', 'task5'], function (error) {
+q2.unshift(['task3', 'task4', 'task5'], function (error: Error) {
     console.log('Finished tasks');
 });
 
-
-// var aq = steed.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
-//     console.log('hello ' + level);
-//     callback(null, level+1);
-// });
-//
-// aq.push(1, function (err : Error, newLevel : number) {
-//     console.log('finished processing bar' + newLevel);
-// });
-
-
 steed.parallel([
-    function (callback: ( err:Error, val:string ) => void ) { },
+    function (callback: (error: Error, val: string) => void) { },
     function (callback) { }
 ],
-function (err:Error,results:Array<string>) {
-    steed.series([
-        function (callback) { },
-        function email_link(callback) { }
-    ]);
-});
-
-steed.parallel([
-    function (callback) {
-        fs.writeFile('testfile1', 'test1', callback);
-    },
-    function (callback) {
-        fs.writeFile('testfile2', 'test2', callback);
-    },
-]);
+    function (error: Error, results: Array<string>) {
+        steed.series([
+            function (callback) { },
+            function email_link(callback) { }
+        ]);
+    });
 
 // each
 
-steed.each<number,Error>({
+steed.each<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.each: ${val}`);
 
@@ -285,7 +260,7 @@ steed.each<number,Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.each: done.");
 
@@ -294,9 +269,9 @@ steed.each<number,Error>({
 steed.eachSeries<number, Error>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function (val: number, next: steed.ErrorCallback<Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.eachSeries: ${val}`);
 
@@ -304,7 +279,7 @@ steed.eachSeries<number, Error>({
 
     }, 500);
 
-}, function(err?: Error): void {
+}, function (err?: Error): void {
 
     console.log("steed.eachSeries: done.");
 
@@ -316,9 +291,9 @@ steed.map<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.map: ${val}`);
 
@@ -326,7 +301,7 @@ steed.map<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.map: done with results", results);
 
@@ -336,9 +311,9 @@ steed.mapSeries<number, string, Error>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: SteedResultCallback<string, Error>): void {
+}, function (val: number, next: steed.SteedResultCallback<string, Error>): void {
 
-    setTimeout(function(): void {
+    setTimeout(function (): void {
 
         console.log(`steed.mapSeries: ${val}`);
 
@@ -346,7 +321,7 @@ steed.mapSeries<number, string, Error>({
 
     }, 500);
 
-}, function(err: Error, results: string[]): void {
+}, function (error: Error, results: string[]): void {
 
     console.log("steed.mapSeries: done with results", results);