diff --git a/orchestrator/orchestrator-test.ts b/orchestrator/orchestrator-test.ts
new file mode 100644
index 000000000..af9af745c
--- /dev/null
+++ b/orchestrator/orchestrator-test.ts
@@ -0,0 +1,106 @@
+/// <reference path="../requirejs/require.d.ts" />
+/// <reference path="orchestrator.d.ts" />
+
+'use strict';
+
+import Orchestrator from 'orchestrator';
+
+var orchestrator = new Orchestrator();
+
+
+// API:
+
+//
+// orchestrator.add(name[, deps][, function]);
+//
+
+orchestrator.add('thing1', function() {
+    // do stuff
+});
+orchestrator.add('thing2', function() {
+    // do stuff
+});
+orchestrator.add('mytask', ['array', 'of', 'task', 'names'], function() {
+    // Do stuff
+});
+orchestrator.add('thing2', function(callback){
+    var err: any = null;
+    // do stuff
+    callback(err);
+});
+
+
+var Q = require('q');
+
+orchestrator.add('thing3', function(){
+    var deferred = Q.defer();
+
+    // do async stuff
+    setTimeout(function () {
+        deferred.resolve();
+    }, 1);
+
+    return deferred.promise;
+});
+
+
+//TODO: map-stream currently not on DefinitelyTyped
+//var map = require('map-stream');
+//
+//orchestrator.add('thing4', function(){
+//    var stream = map(function (args, cb) {
+//        cb(null, args);
+//    });
+//    // do stream stuff
+//    return stream;
+//});
+
+//
+// orchestrator.hasTask(name);
+//
+
+orchestrator.hasTask('thing1');
+
+//
+// orchestrator.start(tasks...[, cb]);
+//
+
+orchestrator.start('thing1', 'thing2', 'thing3', 'thing4', function (err) {
+    // all done
+});
+orchestrator.start(['thing1','thing2'], ['thing3','thing4']);
+
+
+//
+// orchestrator.stop()
+//
+
+orchestrator.stop();
+
+//
+// orchestrator.on(event, cb);
+//
+
+orchestrator.on('task_start', function (e) {
+    var message: string = e.message;
+    var task: string = e.task;
+    var err: any = e.err;
+});
+orchestrator.on('task_stop', function (e) {
+    var message: string = e.message;
+    var task: string = e.task;
+    var duration: number = e.duration;
+});
+
+//
+// orchestrator.onAll(cb);
+//
+
+orchestrator.onAll(function (e) {
+    var message: string = e.message;
+    var task: string = e.task;
+    var err: any = e.err;
+    var src: string = e.src;
+});
+
+
diff --git a/orchestrator/orchestrator.d.ts b/orchestrator/orchestrator.d.ts
new file mode 100644
index 000000000..2948aa927
--- /dev/null
+++ b/orchestrator/orchestrator.d.ts
@@ -0,0 +1,122 @@
+// Type definitions for Orchestrator
+// Project: https://github.com/orchestrator/orchestrator
+// Definitions by: Qubo <https://github.com/tkQubo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../q/Q.d.ts" />
+
+declare type Strings = string|string[];
+
+export interface AddMethodCallback {
+    /**
+     * Accept a callback
+     * @param callback
+     */
+    (callback?: Function): any;
+    /**
+     * Return a promise
+     */
+    (): Q.Promise<any>;
+    /**
+     * Return a stream: (task is marked complete when stream ends)
+     */
+    (): any; //TODO: stream type should be here e.g. map-stream
+}
+
+/**
+ * Define a task
+ */
+export interface AddMethod {
+    /**
+     * Define a task
+     * @param name The name of the task.
+     * @param deps An array of task names to be executed and completed before your task will run.
+     * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
+     * <ul>
+     *     <li>Take in a callback</li>
+     *     <li>Return a stream or a promise</li>
+     * </ul>
+     */
+    (name: string, deps?: string[], fn?: AddMethodCallback|Function): Orchestrator;
+    /**
+     * Define a task
+     * @param name The name of the task.
+     * @param fn The function that performs the task's operations. For asynchronous tasks, you need to provide a hint when the task is complete:
+     * <ul>
+     *     <li>Take in a callback</li>
+     *     <li>Return a stream or a promise</li>
+     * </ul>
+     */
+    (name: string, fn?: AddMethodCallback|Function): Orchestrator;
+}
+
+/**
+ * Start running the tasks
+ */
+export interface StartMethod {
+    /**
+     * Start running the tasks
+     * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments.
+     * @param cb Callback to call after run completed.
+     */
+    (tasks: Strings, cb?: (error?: any) => any): Orchestrator;
+    /**
+     * Start running the tasks
+     * @param tasks Tasks to be executed. You may pass any number of tasks as individual arguments.
+     * @param cb Callback to call after run completed.
+     */
+    (...tasks: Strings[]/*, cb?: (error: any) => any */): Orchestrator;
+    //TODO: TypeScript 1.5.3 cannot express varargs followed by callback as a last argument...
+    (task1: Strings, task2: Strings, cb?: (error?: any) => any): Orchestrator;
+    (task1: Strings, task2: Strings, task3: Strings, cb?: (error?: any) => any): Orchestrator;
+    (task1: Strings, task2: Strings, task3: Strings, task4: Strings, cb?: (error?: any) => any): Orchestrator;
+    (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, cb?: (error?: any) => any): Orchestrator;
+    (task1: Strings, task2: Strings, task3: Strings, task4: Strings, task5: Strings, task6: Strings, cb?: (error?: any) => any): Orchestrator;
+}
+
+export interface OnCallbackEvent {
+    message: string;
+    task: string;
+    err: any;
+    duration?: number;
+}
+
+export interface OnAllCallbackEvent extends OnCallbackEvent {
+    src: string;
+}
+
+declare class Orchestrator {
+    add: AddMethod;
+    /**
+     * Have you defined a task with this name?
+     * @param name The task name to query
+     */
+    hasTask(name: string): boolean;
+    start: StartMethod;
+    stop(): void;
+
+    /**
+     * Listen to orchestrator internals
+     * @param event Event name to listen to:
+     * <ul>
+     *   <li>start: from start() method, shows you the task sequence
+     *   <li>stop: from stop() method, the queue finished successfully
+     *   <li>err: from stop() method, the queue was aborted due to a task error
+     *   <li>task_start: from _runTask() method, task was started
+     *   <li>task_stop: from _runTask() method, task completed successfully
+     *   <li>task_err: from _runTask() method, task errored
+     *   <li>task_not_found: from start() method, you're trying to start a task that doesn't exist
+     *   <li>task_recursion: from start() method, there are recursive dependencies in your task list
+     * </ul>
+     * @param cb Passes single argument: e: event details
+     */
+    on(event: string, cb: (e: OnCallbackEvent) => any): Orchestrator;
+
+    /**
+     * Listen to all orchestrator events from one callback
+     * @param cb Passes single argument: e: event details
+     */
+    onAll(cb: (e: OnAllCallbackEvent) => any): void;
+}
+
+export default Orchestrator;