diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 000000000..8e84accde
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,11 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+root = true
+
+[*]
+indent_size = 2
+indent_style = space
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..0fe29c74d
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,6 @@
+node_modules
+bower_components
+coverage
+.DS_Store
+npm-debug.log
+dist
diff --git a/.travis.yml b/.travis.yml
new file mode 100644
index 000000000..b85fe977a
--- /dev/null
+++ b/.travis.yml
@@ -0,0 +1,11 @@
+language: node_js
+
+notifications:
+  email:
+    on_success: never
+    on_failure: change
+
+node_js:
+  - "0.12"
+
+after_script: "npm install coveralls@2 && cat ./coverage/lcov.info | coveralls"
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 000000000..983fbe8ae
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 000000000..7e612e5bb
--- /dev/null
+++ b/README.md
@@ -0,0 +1,67 @@
+# TypeScript Node
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Build status][travis-image]][travis-url]
+[![Test coverage][coveralls-image]][coveralls-url]
+
+> TypeScript execution environment for node.
+
+## Installation
+
+```
+npm install typescript-node --save
+```
+
+## Features
+
+* Execute TypeScript with node
+* Interactive REPL
+* Execute (and print) TypeScript inline
+* Supports Source Maps
+* Supports `tsconfig.json`
+
+## Usage
+
+```sh
+# Execute a script as you world normally with `node`.
+ts-node script.ts
+
+# Start a TypeScript REPL
+ts-node
+
+# Execute code snippets with TypeScript
+ts-node -e 'console.log("Hello, world!")'
+
+# Execute and print code snippets with TypeScript
+ts-node -p '"Hello, world!"'
+```
+
+### Loading `tsconfig.json`
+
+**Typescript Node** automatically loads `tsconfig.json` options and files from the current directory using [tsconfig](https://github.com/TypeStrong/tsconfig).
+
+### Configuration Options
+
+You can set options by passing them in before the script.
+
+```sh
+ts-node --compiler ntypescript --configFile tsconfig.json --ignoreWarnings 2304 hello-world.ts
+```
+
+* **compiler** Use a custom, require-able TypeScript compiler compatible with `typescript@>=1.5-alpha`
+* **configFile** Manually set the location of the `tsconfig.json` file
+* **ignoreWarnings** Set an array of TypeScript diagnostic codes to ignore
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/typescript-node.svg?style=flat
+[npm-url]: https://npmjs.org/package/typescript-node
+[downloads-image]: https://img.shields.io/npm/dm/typescript-node.svg?style=flat
+[downloads-url]: https://npmjs.org/package/typescript-node
+[travis-image]: https://img.shields.io/travis/blakeembrey/typescript-node.svg?style=flat
+[travis-url]: https://travis-ci.org/blakeembrey/typescript-node
+[coveralls-image]: https://img.shields.io/coveralls/blakeembrey/typescript-node.svg?style=flat
+[coveralls-url]: https://coveralls.io/r/blakeembrey/typescript-node?branch=master
diff --git a/bin.js b/bin.js
new file mode 100755
index 000000000..932ec9501
--- /dev/null
+++ b/bin.js
@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('./dist/bin/ts-node')
diff --git a/package.json b/package.json
new file mode 100644
index 000000000..84b1cb666
--- /dev/null
+++ b/package.json
@@ -0,0 +1,68 @@
+{
+  "name": "typescript-node",
+  "version": "0.0.0",
+  "description": "Feature complete TypeScript environment for node",
+  "main": "dist/typescript-node.js",
+  "bin": {
+    "ts-node": "bin.js"
+  },
+  "files": [
+    "dist/",
+    "typescript-node.d.ts",
+    "bin.js",
+    "register.js",
+    "LICENSE"
+  ],
+  "scripts": {
+    "lint": "# TODO",
+    "build": "npm run build-ts",
+    "build-ts": "rm -rf dist && tsc",
+    "test-spec": "mocha dist/**/*.spec.js -R spec --bail",
+    "test-cov": "istanbul cover node_modules/mocha/bin/_mocha -- dist/**/*.spec.js -R spec --bail",
+    "test": "npm run build && npm run lint && npm run test-cov",
+    "prepublish": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/blakeembrey/typescript-node.git"
+  },
+  "typescript": {
+    "definition": "typescript-node.d.ts"
+  },
+  "keywords": [
+    "typescript",
+    "node",
+    "runtime",
+    "environment",
+    "ts",
+    "compiler"
+  ],
+  "author": {
+    "name": "Blake Embrey",
+    "email": "hello@blakeembrey.com",
+    "url": "http://blakeembrey.me"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/blakeembrey/typescript-node/issues"
+  },
+  "homepage": "https://github.com/blakeembrey/typescript-node",
+  "devDependencies": {
+    "chai": "^3.0.0",
+    "istanbul": "^0.3.17",
+    "mocha": "^2.1.0",
+    "ntypescript": "^1.201507091536.1",
+    "pre-commit": "^1.0.6",
+    "typescript": "^1.5.0-beta"
+  },
+  "peerDependencies": {
+    "typescript": "^1.5.0-alpha"
+  },
+  "dependencies": {
+    "arrify": "^1.0.0",
+    "commander": "^2.8.1",
+    "source-map-support": "^0.3.2",
+    "tsconfig": "^1.0.1",
+    "xtend": "^4.0.0"
+  }
+}
diff --git a/register.js b/register.js
new file mode 100644
index 000000000..ee536c84d
--- /dev/null
+++ b/register.js
@@ -0,0 +1 @@
+require('./').register()
diff --git a/src/bin/ts-node.ts b/src/bin/ts-node.ts
new file mode 100644
index 000000000..c1f31b37f
--- /dev/null
+++ b/src/bin/ts-node.ts
@@ -0,0 +1,204 @@
+import { resolve } from 'path'
+import { Command } from 'commander'
+import { start } from 'repl'
+import { inspect } from 'util'
+import { LanguageService, LanguageServiceHost } from 'typescript'
+import { readFileSync } from 'fs'
+import Module = require('module')
+import extend = require('xtend')
+import { runInThisContext } from 'vm'
+import { register, createError, getInlineSourceMap, getDiagnostics } from '../typescript-node'
+
+var program = new Command('ts-node')
+var pkg = require('../../package.json')
+
+program.option('-e, --eval [code]', 'Evaluate code')
+program.option('-p, --print [code]', 'Evaluate code and print result')
+program.option('--compiler [name]', 'Specify a custom TypeScript compiler')
+program.option('--ignoreWarnings [codes]', 'Specify a custom TypeScript compiler', list)
+program.option('--configFile [path]', 'Specify a custom TypeScript compiler')
+
+program.version(pkg.version)
+program.usage('[options] [ -e script | script.js ] [arguments]')
+program.parse(process.argv)
+
+// TypeScript files must always end with `.ts`.
+const EVAL_FILENAME = '[eval].ts'
+
+const cwd = process.cwd()
+const opts = program.opts()
+const print = opts.print
+const eval = opts.eval
+const code: string = eval == null ? print : eval
+
+// Register returns environment options, helps creating a new language service.
+const compiler = register(opts)
+
+// Defer creation of eval services.
+let files: { [filename: string]: { text: string, version: number } }
+let service: LanguageService
+
+if (typeof code === 'string') {
+  createService()
+
+  global.__filename = EVAL_FILENAME
+  global.__dirname = cwd
+
+  const module = new Module(global.__filename)
+  module.filename = global.__filename
+  module.paths = Module._nodeModulePaths(global.__dirname)
+
+  global.exports = module.exports
+  global.module = module
+  global.require = module.require.bind(module)
+
+  var result = _eval(code, global.__filename)
+
+  if (print != null) {
+    var output = typeof result === 'string' ? result : inspect(result)
+    process.stdout.write(output + '\n')
+  }
+} else {
+  if (program.args.length) {
+    let index = 2
+    let skip = false
+
+    // Skip over TS configuration options.
+    for (; index < process.argv.length; index++) {
+      if (skip) {
+        skip = false
+        continue
+      }
+
+      const arg = process.argv[index]
+
+      // Break on unknown argument value.
+      if (arg.charAt(0) === '-') {
+        const value = opts[arg.substr(2)]
+
+        if (value && value !== true) {
+          skip = true
+        }
+
+        continue
+      }
+
+      break
+    }
+
+    const args = process.argv.slice(index)
+
+    // Make the filename absolute.
+    args[0] = resolve(args[0])
+
+    process.argv = ['node'].concat(args)
+    process.execArgv.unshift(__filename)
+
+    Module.runMain()
+  } else {
+    createService()
+    startRepl()
+  }
+}
+
+/**
+ * Evaluate the code snippet.
+ */
+function _eval (text: string, filename: string) {
+  if (!files[filename]) {
+    files[filename] = { version: 0, text: '' }
+  }
+
+  const file = files[filename]
+
+  file.text = text
+  file.version++
+
+  const output = service.getEmitOutput(filename)
+  const diagnostics = getDiagnostics(service, filename, compiler.options)
+
+  if (diagnostics.length) {
+    throw createError(diagnostics, compiler.ts)
+  }
+
+  const result = output.outputFiles[1].text
+  const sourceMap = output.outputFiles[0].text
+
+  const code = result.replace(
+    '//# sourceMappingURL=' + filename.replace(/\.ts$/, '.js.map'),
+    '//# sourceMappingURL=' + getInlineSourceMap(sourceMap, filename, text)
+  )
+
+  return runInThisContext(result, filename)
+}
+
+/**
+ * Create an inline eval service on demand.
+ */
+function createService () {
+  const { ts, registry, config } = compiler
+
+  // Initialize files object.
+  files = {}
+
+  // Create language services for `eval`.
+  service = ts.createLanguageService(<LanguageServiceHost> {
+    getScriptFileNames: () => {
+      return config.fileNames.concat(Object.keys(files))
+    },
+    getScriptVersion: (fileName) => files[fileName] && files[fileName].version.toString(),
+    getScriptSnapshot (fileName) {
+      const file = files[fileName]
+
+      if (file) {
+        return ts.ScriptSnapshot.fromString(file.text)
+      }
+
+      try {
+        return ts.ScriptSnapshot.fromString(readFileSync(fileName, 'utf-8'))
+      } catch (e) {
+        return
+      }
+    },
+    getCurrentDirectory: () => cwd,
+    getScriptIsOpen: () => true,
+    getCompilationSettings: () => extend(config.options, { sourceMap: true }),
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(options)
+  }, registry)
+}
+
+/**
+ * Start a CLI REPL.
+ */
+function startRepl () {
+  return start({
+    prompt: '> ',
+    input: process.stdin,
+    output: process.stdout,
+    eval: replEval,
+    useGlobal: true
+  })
+}
+
+/**
+ * Eval code from the REPL.
+ */
+function replEval (code: string, context: any, filename: string, callback: (err: Error, result: any) => any) {
+  let err: Error
+  let result: any
+
+  try {
+    result = _eval(code, EVAL_FILENAME)
+  } catch (e) {
+    err = e
+  }
+
+  callback(err, result)
+}
+
+/**
+ * Split a string of values into an array.
+ */
+function list (value: string) {
+  return value.split(/ *, */)
+}
diff --git a/src/typescript-node.spec.ts b/src/typescript-node.spec.ts
new file mode 100644
index 000000000..5d2dd7757
--- /dev/null
+++ b/src/typescript-node.spec.ts
@@ -0,0 +1,25 @@
+import { expect } from 'chai'
+import { exec } from 'child_process'
+import { join } from 'path'
+import { register } from './typescript-node'
+
+const BIN_PATH = join(__dirname, '../dist/bin/ts-node')
+
+const compiler = register()
+
+describe('ts-node', function () {
+  it('should execute cli', function (done) {
+    exec(`node ${BIN_PATH} ${join(__dirname, '../tests/hello-world')}`, function (err, stdout) {
+      expect(err).to.not.exist
+      expect(stdout).to.equal('Hello, world!\n')
+
+      return done()
+    })
+  })
+
+  it('should be able to require typescript', function () {
+    var m = require('../tests/module')
+
+    expect(m.example()).to.be.true
+  })
+})
diff --git a/src/typescript-node.ts b/src/typescript-node.ts
new file mode 100644
index 000000000..e74d104f2
--- /dev/null
+++ b/src/typescript-node.ts
@@ -0,0 +1,197 @@
+import * as TS from 'typescript'
+import * as tsconfig from 'tsconfig'
+import { resolve } from 'path'
+import * as fs from 'fs'
+import { EOL } from 'os'
+import sourceMapSupport = require('source-map-support')
+import extend = require('xtend')
+import arrify = require('arrify')
+
+const cwd = process.cwd()
+const readFileSync = fs.readFileSync
+
+/**
+ * Extensions to compile using TypeScript.
+ */
+export const EXTENSIONS = ['.ts', '.tsx']
+
+/**
+ * Registration options.
+ */
+export interface Options {
+  compiler?: string
+  configFile?: string
+  ignoreWarnings?: string[]
+}
+
+/**
+ * Load TypeScript configuration.
+ */
+function readConfig (fileName: string, ts: typeof TS) {
+  const config = fileName ? tsconfig.readFileSync(fileName) : {
+    files: [],
+    compilerOptions: {}
+  }
+
+  config.compilerOptions = extend({
+    target: 'es5'
+  }, config.compilerOptions, {
+    module: 'commonjs'
+  })
+
+  return ts.parseConfigFile(config, ts.sys, fileName)
+}
+
+/**
+ * Register TypeScript compiler.
+ */
+export function register (opts?: Options) {
+  const options = extend(opts)
+
+  const maps: { [fileName: string]: string } = {}
+  const files: { [fileName: string]: boolean } = {}
+
+  // Enable compiler overrides.
+  options.compiler = options.compiler || 'typescript'
+
+  // Ensure `ignoreWarnings` is always an array.
+  options.ignoreWarnings = arrify(options.ignoreWarnings)
+
+  // Resolve configuration file options.
+  options.configFile = options.configFile ?
+    resolve(cwd, options.configFile) :
+    tsconfig.resolveSync(cwd)
+
+  const ts: typeof TS = require(options.compiler)
+  const config = readConfig(options.configFile, ts)
+
+  if (config.errors.length) {
+    throw createError(config.errors, ts)
+  }
+
+  const serviceHost: TS.LanguageServiceHost = {
+    getScriptFileNames: () => config.fileNames.concat(Object.keys(files)),
+    getScriptVersion: (fileName) => 'node',
+    getScriptSnapshot (fileName): TS.IScriptSnapshot {
+      try {
+        return ts.ScriptSnapshot.fromString(readFileSync(fileName, 'utf-8'))
+      } catch (e) {
+        return
+      }
+    },
+    getCurrentDirectory: () => cwd,
+    getScriptIsOpen: () => true,
+    getCompilationSettings: () => config.options,
+    getDefaultLibFileName: (options) => ts.getDefaultLibFilePath(config.options)
+  }
+
+  const registry = ts.createDocumentRegistry()
+  const service = ts.createLanguageService(serviceHost, registry)
+  const hasSourceMap = config.options.sourceMap
+
+  const retrieveSourceMap = sourceMapSupport.retrieveSourceMap
+
+  // Install source map support and read from cache.
+  sourceMapSupport.install({
+    handleUncaughtExceptions: false,
+    retrieveSourceMap (filename: string) {
+      var map = maps && maps[filename]
+
+      if (map) {
+        return <sourceMapSupport.UrlAndMap> { map, url: null }
+      }
+
+      return retrieveSourceMap(filename)
+    }
+  })
+
+  function compile (fileName: string) {
+    files[fileName] = true
+
+    const output = service.getEmitOutput(fileName)
+    const result = output.outputFiles[hasSourceMap ? 1 : 0].text
+
+    // Cache source maps where provided.
+    if (hasSourceMap) {
+      maps[output.outputFiles[0].name] = output.outputFiles[0].text
+    }
+
+    // Log all diagnostics before exiting the program.
+    const diagnostics = getDiagnostics(service, fileName, options)
+
+    if (diagnostics.length) {
+      throw createError(diagnostics, ts)
+    }
+
+    return result
+  }
+
+  function loader (m: any, fileName: string) {
+    return m._compile(compile(fileName), fileName)
+  }
+
+  // Attach the loader to each defined extension.
+  EXTENSIONS.forEach(function (extension) {
+    require.extensions[extension] = loader
+  })
+
+  return {
+    registry,
+    ts,
+    config,
+    options
+  }
+}
+
+/**
+ * Get file diagnostics from a TypeScript language service.
+ */
+export function getDiagnostics (service: TS.LanguageService, fileName: string, options: Options) {
+  return service.getCompilerOptionsDiagnostics()
+    .concat(service.getSyntacticDiagnostics(fileName))
+    .concat(service.getSemanticDiagnostics(fileName))
+    .filter(function (diagnostic) {
+      return options.ignoreWarnings.indexOf(String(diagnostic.code)) === -1
+    })
+}
+
+/**
+ * Format a diagnostic object into a string.
+ */
+export function formatDiagnostic (diagnostic: TS.Diagnostic, ts: typeof TS): string {
+  const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')
+
+  if (diagnostic.file) {
+    const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start)
+
+    return `TS${diagnostic.code} (${line + 1},${character + 1}): ${message}`
+  }
+
+  return message
+}
+
+/**
+ * Create a "TypeScript" error.
+ */
+export function createError (diagnostics: TS.Diagnostic[], ts: typeof TS): Error {
+  const message = ['Unable to compile TypeScript:']
+    .concat(diagnostics.map((d) => formatDiagnostic(d, ts)))
+    .join(EOL)
+
+  const err = new Error(message)
+  err.name = 'TypeScriptError'
+  return err
+}
+
+/**
+ * Generate an base 64 inline source map.
+ */
+export function getInlineSourceMap (map: string, fileName: string, code: string): string {
+  var sourceMap = JSON.parse(map)
+  sourceMap.file = fileName
+  sourceMap.sources = [fileName]
+  sourceMap.sourcesContent = [code]
+  delete sourceMap.sourceRoot
+  const inlineSourceMap = new Buffer(JSON.stringify(sourceMap)).toString('base64')
+  return 'data:application/json;base64,' + inlineSourceMap
+}
diff --git a/src/typings/arrify.d.ts b/src/typings/arrify.d.ts
new file mode 100644
index 000000000..b99318ac7
--- /dev/null
+++ b/src/typings/arrify.d.ts
@@ -0,0 +1,5 @@
+declare module 'arrify' {
+  function arrify <T> (arr: T | T[]): T[]
+
+  export = arrify
+}
diff --git a/src/typings/node.d.ts b/src/typings/node.d.ts
new file mode 100644
index 000000000..a1f6bdea9
--- /dev/null
+++ b/src/typings/node.d.ts
@@ -0,0 +1,21 @@
+declare module NodeJS {
+  interface Process {
+    execArgv: string[]
+  }
+}
+
+declare module 'module' {
+  class Module {
+    static runMain (): void
+    static _nodeModulePaths (path: string): string[]
+
+    constructor (filename: string)
+
+    filename: string
+    paths: string[]
+    exports: any
+    require (module: string): any
+  }
+
+  export = Module
+}
diff --git a/src/typings/xtend.d.ts b/src/typings/xtend.d.ts
new file mode 100644
index 000000000..94f9c51d6
--- /dev/null
+++ b/src/typings/xtend.d.ts
@@ -0,0 +1,17 @@
+declare module 'xtend/mutable' {
+  function extend <T> (dest: T, ...src: Object[]): T
+
+  export = extend
+}
+
+declare module 'xtend/immutable' {
+  function extend <T> (dest: T, ...src: Object[]): T
+
+  export = extend
+}
+
+declare module 'xtend' {
+  import immutable = require('xtend/immutable')
+
+  export = immutable
+}
diff --git a/tests/example.ts b/tests/example.ts
new file mode 100644
index 000000000..0709b39bb
--- /dev/null
+++ b/tests/example.ts
@@ -0,0 +1,5 @@
+describe('typescript-node', function () {
+  it('should execute', function (done: (err?: Error) => any) {
+    done()
+  })
+})
diff --git a/tests/hello-world.ts b/tests/hello-world.ts
new file mode 100644
index 000000000..19dfa14da
--- /dev/null
+++ b/tests/hello-world.ts
@@ -0,0 +1 @@
+console.log('Hello, world!')
diff --git a/tests/module.ts b/tests/module.ts
new file mode 100644
index 000000000..fda86994a
--- /dev/null
+++ b/tests/module.ts
@@ -0,0 +1,3 @@
+export function example (foo: string): boolean {
+  return true
+}
diff --git a/tsconfig.json b/tsconfig.json
new file mode 100644
index 000000000..5d2c40cab
--- /dev/null
+++ b/tsconfig.json
@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "outDir": "dist",
+    "module": "commonjs",
+    "declaration": true,
+    "noImplicitAny": true,
+    "removeComments": true,
+    "sourceMap": true
+  },
+  "files": [
+    "src/typescript-node.ts",
+    "src/typescript-node.spec.ts",
+    "src/bin/ts-node.ts",
+    "typings/tsd.d.ts",
+    "src/typings/node.d.ts",
+    "src/typings/xtend.d.ts",
+    "src/typings/arrify.d.ts"
+  ]
+}
diff --git a/tsd.json b/tsd.json
new file mode 100644
index 000000000..e65fe9e70
--- /dev/null
+++ b/tsd.json
@@ -0,0 +1,24 @@
+{
+  "version": "v4",
+  "repo": "borisyankov/DefinitelyTyped",
+  "ref": "master",
+  "path": "typings",
+  "bundle": "typings/tsd.d.ts",
+  "installed": {
+    "chai/chai.d.ts": {
+      "commit": "b37afda34daa6186c3f143609555fcd6d70b249f"
+    },
+    "mocha/mocha.d.ts": {
+      "commit": "b37afda34daa6186c3f143609555fcd6d70b249f"
+    },
+    "node/node.d.ts": {
+      "commit": "b37afda34daa6186c3f143609555fcd6d70b249f"
+    },
+    "source-map-support/source-map-support.d.ts": {
+      "commit": "f999dcd9543265848a33fa3bb8379bf0393d33c8"
+    },
+    "commander/commander.d.ts": {
+      "commit": "f999dcd9543265848a33fa3bb8379bf0393d33c8"
+    }
+  }
+}
diff --git a/typescript-node.d.ts b/typescript-node.d.ts
new file mode 100644
index 000000000..2e3341c85
--- /dev/null
+++ b/typescript-node.d.ts
@@ -0,0 +1,5 @@
+declare module 'typescript-node' {
+  import TypeScriptNode = require('dist/typescript-node')
+
+  export = TypeScriptNode
+}
diff --git a/typings/chai/chai.d.ts b/typings/chai/chai.d.ts
new file mode 100644
index 000000000..4b9d313dd
--- /dev/null
+++ b/typings/chai/chai.d.ts
@@ -0,0 +1,285 @@
+// Type definitions for chai 2.0.0
+// Project: http://chaijs.com/
+// Definitions by: Jed Hunsaker <https://github.com/jedhunsaker/>, Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module chai {
+    export class AssertionError {
+        constructor(message: string, _props?: any, ssf?: Function);
+        name: string;
+        message: string;
+        showDiff: boolean;
+        stack: string;
+    }
+
+    export function expect(target: any, message?: string): Expect;
+
+    export var assert: Assert;
+    export var config: Config;
+
+    export interface Config {
+        includeStack: boolean;
+    }
+
+    // Provides a way to extend the internals of Chai
+    function use(fn: (chai: any, utils: any) => void): any;
+
+    interface ExpectStatic {
+        (target: any): Expect;
+    }
+
+    interface Assertions {
+        attr(name: string, value?: string): any;
+        css(name: string, value?: string): any;
+        data(name: string, value?: string): any;
+        class(className: string): any;
+        id(id: string): any;
+        html(html: string): any;
+        text(text: string): any;
+        value(value: string): any;
+        visible: any;
+        hidden: any;
+        selected: any;
+        checked: any;
+        disabled: any;
+        empty: any;
+        exist: any;
+    }
+
+    interface Expect extends LanguageChains, NumericComparison, TypeComparison, Assertions {
+        not: Expect;
+        deep: Deep;
+        a: TypeComparison;
+        an: TypeComparison;
+        include: Include;
+        contain: Include;
+        ok: Expect;
+        true: Expect;
+        false: Expect;
+        null: Expect;
+        undefined: Expect;
+        exist: Expect;
+        empty: Expect;
+        arguments: Expect;
+        Arguments: Expect;
+        equal: Equal;
+        equals: Equal;
+        eq: Equal;
+        eql: Equal;
+        eqls: Equal;
+        property: Property;
+        ownProperty: OwnProperty;
+        haveOwnProperty: OwnProperty;
+        length: Length;
+        lengthOf: Length;
+        match(RegularExpression: RegExp, message?: string): Expect;
+        string(string: string, message?: string): Expect;
+        keys: Keys;
+        key(string: string): Expect;
+        throw: Throw;
+        throws: Throw;
+        Throw: Throw;
+        respondTo(method: string, message?: string): Expect;
+        itself: Expect;
+        satisfy(matcher: Function, message?: string): Expect;
+        closeTo(expected: number, delta: number, message?: string): Expect;
+        members: Members;
+    }
+
+    interface LanguageChains {
+        to: Expect;
+        be: Expect;
+        been: Expect;
+        is: Expect;
+        that: Expect;
+        which: Expect;
+        and: Expect;
+        have: Expect;
+        has: Expect;
+        with: Expect;
+        at: Expect;
+        of: Expect;
+        same: Expect;
+    }
+
+    interface NumericComparison {
+        above: NumberComparer;
+        gt: NumberComparer;
+        greaterThan: NumberComparer;
+        least: NumberComparer;
+        gte: NumberComparer;
+        below: NumberComparer;
+        lt: NumberComparer;
+        lessThan: NumberComparer;
+        most: NumberComparer;
+        lte: NumberComparer;
+        within(start: number, finish: number, message?: string): Expect;
+    }
+
+    interface NumberComparer {
+        (value: number, message?: string): Expect;
+    }
+
+    interface TypeComparison {
+        (type: string, message?: string): Expect;
+        instanceof: InstanceOf;
+        instanceOf: InstanceOf;
+    }
+
+    interface InstanceOf {
+        (constructor: Object, message?: string): Expect;
+    }
+
+    interface Deep {
+        equal: Equal;
+        property: Property;
+    }
+
+    interface Equal {
+        (value: any, message?: string): Expect;
+    }
+
+    interface Property {
+        (name: string, value?: any, message?: string): Expect;
+    }
+
+    interface OwnProperty {
+        (name: string, message?: string): Expect;
+    }
+
+    interface Length extends LanguageChains, NumericComparison {
+        (length: number, message?: string): Expect;
+    }
+
+    interface Include {
+        (value: Object, message?: string): Expect;
+        (value: string, message?: string): Expect;
+        (value: number, message?: string): Expect;
+        keys: Keys;
+        members: Members;
+    }
+
+    interface Keys {
+        (...keys: string[]): Expect;
+        (keys: any[]): Expect;
+    }
+
+    interface Members {
+        (set: any[], message?: string): Expect;
+    }
+
+    interface Throw {
+        (): Expect;
+        (expected: string, message?: string): Expect;
+        (expected: RegExp, message?: string): Expect;
+        (constructor: Error, expected?: string, message?: string): Expect;
+        (constructor: Error, expected?: RegExp, message?: string): Expect;
+        (constructor: Function, expected?: string, message?: string): Expect;
+        (constructor: Function, expected?: RegExp, message?: string): Expect;
+    }
+
+    export interface Assert {
+        (express: any, msg?: string):void;
+
+        fail(actual?: any, expected?: any, msg?: string, operator?: string):void;
+
+        ok(val: any, msg?: string):void;
+        notOk(val: any, msg?: string):void;
+
+        equal(act: any, exp: any, msg?: string):void;
+        notEqual(act: any, exp: any, msg?: string):void;
+
+        strictEqual(act: any, exp: any, msg?: string):void;
+        notStrictEqual(act: any, exp: any, msg?: string):void;
+
+        deepEqual(act: any, exp: any, msg?: string):void;
+        notDeepEqual(act: any, exp: any, msg?: string):void;
+
+        isTrue(val: any, msg?: string):void;
+        isFalse(val: any, msg?: string):void;
+
+        isNull(val: any, msg?: string):void;
+        isNotNull(val: any, msg?: string):void;
+
+        isUndefined(val: any, msg?: string):void;
+        isDefined(val: any, msg?: string):void;
+
+        isFunction(val: any, msg?: string):void;
+        isNotFunction(val: any, msg?: string):void;
+
+        isObject(val: any, msg?: string):void;
+        isNotObject(val: any, msg?: string):void;
+
+        isArray(val: any, msg?: string):void;
+        isNotArray(val: any, msg?: string):void;
+
+        isString(val: any, msg?: string):void;
+        isNotString(val: any, msg?: string):void;
+
+        isNumber(val: any, msg?: string):void;
+        isNotNumber(val: any, msg?: string):void;
+
+        isBoolean(val: any, msg?: string):void;
+        isNotBoolean(val: any, msg?: string):void;
+
+        typeOf(val: any, type: string, msg?: string):void;
+        notTypeOf(val: any, type: string, msg?: string):void;
+
+        instanceOf(val: any, type: Function, msg?: string):void;
+        notInstanceOf(val: any, type: Function, msg?: string):void;
+
+        include(exp: string, inc: any, msg?: string):void;
+        include(exp: any[], inc: any, msg?: string):void;
+
+        notInclude(exp: string, inc: any, msg?: string):void;
+        notInclude(exp: any[], inc: any, msg?: string):void;
+
+        match(exp: any, re: RegExp, msg?: string):void;
+        notMatch(exp: any, re: RegExp, msg?: string):void;
+
+        property(obj: Object, prop: string, msg?: string):void;
+        notProperty(obj: Object, prop: string, msg?: string):void;
+        deepProperty(obj: Object, prop: string, msg?: string):void;
+        notDeepProperty(obj: Object, prop: string, msg?: string):void;
+
+        propertyVal(obj: Object, prop: string, val: any, msg?: string):void;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string):void;
+
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string):void;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string):void;
+
+        lengthOf(exp: any, len: number, msg?: string):void;
+        //alias frenzy
+        throw(fn: Function, msg?: string):void;
+        throw(fn: Function, regExp: RegExp):void;
+        throw(fn: Function, errType: Function, msg?: string):void;
+        throw(fn: Function, errType: Function, regExp: RegExp):void;
+
+        throws(fn: Function, msg?: string):void;
+        throws(fn: Function, regExp: RegExp):void;
+        throws(fn: Function, errType: Function, msg?: string):void;
+        throws(fn: Function, errType: Function, regExp: RegExp):void;
+
+        Throw(fn: Function, msg?: string):void;
+        Throw(fn: Function, regExp: RegExp):void;
+        Throw(fn: Function, errType: Function, msg?: string):void;
+        Throw(fn: Function, errType: Function, regExp: RegExp):void;
+
+        doesNotThrow(fn: Function, msg?: string):void;
+        doesNotThrow(fn: Function, regExp: RegExp):void;
+        doesNotThrow(fn: Function, errType: Function, msg?: string):void;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp):void;
+
+        operator(val: any, operator: string, val2: any, msg?: string):void;
+        closeTo(act: number, exp: number, delta: number, msg?: string):void;
+
+        sameMembers(set1: any[], set2: any[], msg?: string):void;
+        includeMembers(set1: any[], set2: any[], msg?: string):void;
+
+        ifError(val: any, msg?: string):void;
+    }
+}
+
+declare module "chai" {
+    export = chai;
+}
diff --git a/typings/commander/commander.d.ts b/typings/commander/commander.d.ts
new file mode 100644
index 000000000..09d796659
--- /dev/null
+++ b/typings/commander/commander.d.ts
@@ -0,0 +1,402 @@
+// Type definitions for commanderjs 2.3.0
+// Project: https://github.com/visionmedia/commander.js
+// Definitions by: Marcelo Dezem <http://github.com/mdezem>, vvakame <http://github.com/vvakame>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module commander {
+    interface ICommandStatic {
+        /**
+         * Initialize a new `Command`.
+         *
+         * @param {String} name
+         * @api public
+         */
+        new (name?:string):ICommand;
+    }
+
+    interface ICommand extends NodeJS.EventEmitter {
+        args: string[];
+        _args: { required:boolean; name: string; }[];
+
+        /**
+         * Add command `name`.
+         *
+         * The `.action()` callback is invoked when the
+         * command `name` is specified via __ARGV__,
+         * and the remaining arguments are applied to the
+         * function for access.
+         *
+         * When the `name` is "*" an un-matched command
+         * will be passed as the first arg, followed by
+         * the rest of __ARGV__ remaining.
+         *
+         * Examples:
+         *
+         *      program
+         *        .version('0.0.1')
+         *        .option('-C, --chdir <path>', 'change the working directory')
+         *        .option('-c, --config <path>', 'set config path. defaults to ./deploy.conf')
+         *        .option('-T, --no-tests', 'ignore test hook')
+         *
+         *      program
+         *        .command('setup')
+         *        .description('run remote setup commands')
+         *        .action(function(){
+         *          console.log('setup');
+         *        });
+         *
+         *      program
+         *        .command('exec <cmd>')
+         *        .description('run the given remote command')
+         *        .action(function(cmd){
+         *          console.log('exec "%s"', cmd);
+         *        });
+         *
+         *      program
+         *        .command('*')
+         *        .description('deploy the given env')
+         *        .action(function(env){
+         *          console.log('deploying "%s"', env);
+         *        });
+         *
+         *      program.parse(process.argv);
+         *
+         * @param {String} name
+         * @param {String} [desc]
+         * @return {Command} the new command
+         * @api public
+         */
+        command(name:string, desc?:string):ICommand;
+
+        /**
+         * Add an implicit `help [cmd]` subcommand
+         * which invokes `--help` for the given command.
+         *
+         * @api private
+         */
+        addImplicitHelpCommand():void;
+
+        /**
+         * Parse expected `args`.
+         *
+         * For example `["[type]"]` becomes `[{ required: false, name: 'type' }]`.
+         *
+         * @param {Array} args
+         * @return {Command} for chaining
+         * @api public
+         */
+        parseExpectedArgs(args:string[]):ICommand;
+
+        /**
+         * Register callback `fn` for the command.
+         *
+         * Examples:
+         *
+         *      program
+         *        .command('help')
+         *        .description('display verbose help')
+         *        .action(function(){
+         *           // output help here
+         *        });
+         *
+         * @param {Function} fn
+         * @return {Command} for chaining
+         * @api public
+         */
+        action(fn:(...args:any[])=>void):ICommand;
+
+        /**
+         * Define option with `flags`, `description` and optional
+         * coercion `fn`.
+         *
+         * The `flags` string should contain both the short and long flags,
+         * separated by comma, a pipe or space. The following are all valid
+         * all will output this way when `--help` is used.
+         *
+         *    "-p, --pepper"
+         *    "-p|--pepper"
+         *    "-p --pepper"
+         *
+         * Examples:
+         *
+         *     // simple boolean defaulting to false
+         *     program.option('-p, --pepper', 'add pepper');
+         *
+         *     --pepper
+         *     program.pepper
+         *     // => Boolean
+         *
+         *     // simple boolean defaulting to true
+         *     program.option('-C, --no-cheese', 'remove cheese');
+         *
+         *     program.cheese
+         *     // => true
+         *
+         *     --no-cheese
+         *     program.cheese
+         *     // => false
+         *
+         *     // required argument
+         *     program.option('-C, --chdir <path>', 'change the working directory');
+         *
+         *     --chdir /tmp
+         *     program.chdir
+         *     // => "/tmp"
+         *
+         *     // optional argument
+         *     program.option('-c, --cheese [type]', 'add cheese [marble]');
+         *
+         * @param {String} flags
+         * @param {String} description
+         * @param {Function|Mixed} fn or default
+         * @param {Mixed} defaultValue
+         * @return {Command} for chaining
+         * @api public
+         */
+        option(flags:string, description?:string, fn?:(arg1:any, arg2:any)=>void, defaultValue?:any):ICommand;
+        option(flags:string, description?:string, defaultValue?:any):ICommand;
+
+        /**
+         * Parse `argv`, settings options and invoking commands when defined.
+         *
+         * @param {Array} argv
+         * @return {Command} for chaining
+         * @api public
+         */
+        parse(argv:string[]):ICommand;
+
+        /**
+         * Execute a sub-command executable.
+         *
+         * @param {Array} argv
+         * @param {Array} args
+         * @param {Array} unknown
+         * @api private
+         */
+        executeSubCommand(argv:string[], args:string[], unknown:string[]):any; /* child_process.ChildProcess */
+
+        /**
+         * Normalize `args`, splitting joined short flags. For example
+         * the arg "-abc" is equivalent to "-a -b -c".
+         * This also normalizes equal sign and splits "--abc=def" into "--abc def".
+         *
+         * @param {Array} args
+         * @return {Array}
+         * @api private
+         */
+        normalize(args:string[]):string[];
+
+        /**
+         * Parse command `args`.
+         *
+         * When listener(s) are available those
+         * callbacks are invoked, otherwise the "*"
+         * event is emitted and those actions are invoked.
+         *
+         * @param {Array} args
+         * @return {Command} for chaining
+         * @api private
+         */
+        parseArgs(args:string[], unknown:string[]):ICommand;
+
+        /**
+         * Return an option matching `arg` if any.
+         *
+         * @param {String} arg
+         * @return {Option}
+         * @api private
+         */
+        optionFor(arg:string):IOption;
+
+        /**
+         * Parse options from `argv` returning `argv`
+         * void of these options.
+         *
+         * @param {Array} argv
+         * @return {Array}
+         * @api public
+         */
+        parseOptions(argv:string[]): {args:string[]; unknown:string[];};
+
+        /**
+         * Return an object containing options as key-value pairs
+         *
+         * @return {Object}
+         * @api public
+         */
+        opts():any;
+
+        /**
+         * Argument `name` is missing.
+         *
+         * @param {String} name
+         * @api private
+         */
+        missingArgument(name:string):void;
+
+        /**
+         * `Option` is missing an argument, but received `flag` or nothing.
+         *
+         * @param {String} option
+         * @param {String} flag
+         * @api private
+         */
+        optionMissingArgument(option:{flags:string;}, flag?:string):void;
+
+        /**
+         * Unknown option `flag`.
+         *
+         * @param {String} flag
+         * @api private
+         */
+        unknownOption(flag:string):void;
+
+        /**
+         * Set the program version to `str`.
+         *
+         * This method auto-registers the "-V, --version" flag
+         * which will print the version number when passed.
+         *
+         * @param {String} str
+         * @param {String} flags
+         * @return {Command} for chaining
+         * @api public
+         */
+        version(str:string, flags?:string):ICommand;
+
+        /**
+         * Set the description to `str`.
+         *
+         * @param {String} str
+         * @return {String|Command}
+         * @api public
+         */
+        description(str:string):ICommand;
+        description():string;
+
+        /**
+         * Set an alias for the command
+         *
+         * @param {String} alias
+         * @return {String|Command}
+         * @api public
+         */
+        alias(alias:string):ICommand;
+        alias():string;
+
+        /**
+         * Set / get the command usage `str`.
+         *
+         * @param {String} str
+         * @return {String|Command}
+         * @api public
+         */
+        usage(str:string):ICommand;
+        usage():string;
+
+        /**
+         * Get the name of the command
+         *
+         * @param {String} name
+         * @return {String|Command}
+         * @api public
+         */
+        name():string;
+
+        /**
+         * Return the largest option length.
+         *
+         * @return {Number}
+         * @api private
+         */
+        largestOptionLength():number;
+
+        /**
+         * Return help for options.
+         *
+         * @return {String}
+         * @api private
+         */
+        optionHelp():string;
+
+        /**
+         * Return command help documentation.
+         *
+         * @return {String}
+         * @api private
+         */
+        commandHelp():string;
+
+        /**
+         * Return program help documentation.
+         *
+         * @return {String}
+         * @api private
+         */
+        helpInformation():string;
+
+        /**
+         * Output help information for this command
+         *
+         * @api public
+         */
+        outputHelp():void;
+
+        /**
+         * Output help information and exit.
+         *
+         * @api public
+         */
+        help():void;
+    }
+
+    interface IOptionStatic {
+        /**
+         * Initialize a new `Option` with the given `flags` and `description`.
+         *
+         * @param {String} flags
+         * @param {String} description
+         * @api public
+         */
+        new (flags:string, description?:string):IOption;
+    }
+
+    interface IOption {
+        flags:string;
+        required:boolean;
+        optional:boolean;
+        bool:boolean;
+        short?:string;
+        long:string;
+        description:string;
+
+        /**
+         * Return option name.
+         *
+         * @return {String}
+         * @api private
+         */
+        name():string;
+
+        /**
+         * Check if `arg` matches the short or long flag.
+         *
+         * @param {String} arg
+         * @return {Boolean}
+         * @api private
+         */
+        is(arg:string):boolean;
+    }
+
+    interface IExportedCommand extends ICommand {
+        Command: commander.ICommandStatic;
+        Option: commander.IOptionStatic;
+    }
+}
+
+declare module "commander" {
+    var _tmp:commander.IExportedCommand;
+    export = _tmp;
+}
diff --git a/typings/mocha/mocha.d.ts b/typings/mocha/mocha.d.ts
new file mode 100644
index 000000000..3f5d3e571
--- /dev/null
+++ b/typings/mocha/mocha.d.ts
@@ -0,0 +1,147 @@
+// Type definitions for mocha 2.0.1
+// Project: http://mochajs.org/
+// Definitions by: Kazi Manzur Rashid <https://github.com/kazimanzurrashid/>, otiai10 <https://github.com/otiai10>, jt000 <https://github.com/jt000>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Mocha {
+    // Setup mocha with the given setting options.
+    setup(options: MochaSetupOptions): Mocha;
+
+    //Run tests and invoke `fn()` when complete.
+    run(callback?: () => void): void;
+
+    // Set reporter as function
+    reporter(reporter: () => void): Mocha;
+
+    // Set reporter, defaults to "dot"
+    reporter(reporter: string): Mocha;
+
+    // Enable growl support.
+    growl(): Mocha
+}
+
+interface MochaSetupOptions {
+    //milliseconds to wait before considering a test slow
+    slow?: number;
+
+    // timeout in milliseconds
+    timeout?: number;
+
+    // ui name "bdd", "tdd", "exports" etc
+    ui?: string;
+
+    //array of accepted globals
+    globals?: any[];
+
+    // reporter instance (function or string), defaults to `mocha.reporters.Dot`
+    reporter?: any;
+
+    // bail on the first test failure
+    bail?: boolean;
+
+    // ignore global leaks
+    ignoreLeaks?: boolean;
+
+    // grep string or regexp to filter tests with
+    grep?: any;
+}
+
+interface MochaDone {
+    (error?: Error): void;
+}
+
+declare var mocha: Mocha;
+
+declare var describe : {
+    (description: string, spec: () => void): void;
+    only(description: string, spec: () => void): void;
+    skip(description: string, spec: () => void): void;
+    timeout(ms: number): void;
+}
+
+// alias for `describe`
+declare var context : {
+    (contextTitle: string, spec: () => void): void;
+    only(contextTitle: string, spec: () => void): void;
+    skip(contextTitle: string, spec: () => void): void;
+    timeout(ms: number): void;
+}
+
+declare var it: {
+    (expectation: string, assertion?: () => void): void;
+    (expectation: string, assertion?: (done: MochaDone) => void): void;
+    only(expectation: string, assertion?: () => void): void;
+    only(expectation: string, assertion?: (done: MochaDone) => void): void;
+    skip(expectation: string, assertion?: () => void): void;
+    skip(expectation: string, assertion?: (done: MochaDone) => void): void;
+    timeout(ms: number): void;
+};
+
+declare function before(action: () => void): void;
+
+declare function before(action: (done: MochaDone) => void): void;
+
+declare function setup(action: () => void): void;
+
+declare function setup(action: (done: MochaDone) => void): void;
+
+declare function after(action: () => void): void;
+
+declare function after(action: (done: MochaDone) => void): void;
+
+declare function teardown(action: () => void): void;
+
+declare function teardown(action: (done: MochaDone) => void): void;
+
+declare function beforeEach(action: () => void): void;
+
+declare function beforeEach(action: (done: MochaDone) => void): void;
+
+declare function suiteSetup(action: () => void): void;
+
+declare function suiteSetup(action: (done: MochaDone) => void): void;
+
+declare function afterEach(action: () => void): void;
+
+declare function afterEach(action: (done: MochaDone) => void): void;
+
+declare function suiteTeardown(action: () => void): void;
+
+declare function suiteTeardown(action: (done: MochaDone) => void): void;
+
+declare module "mocha" {
+
+    class Mocha {
+        constructor(options?: {
+            grep?: RegExp;
+            ui?: string;
+            reporter?: string;
+            timeout?: number;
+            bail?: boolean;
+        });
+
+        bail(value?: boolean): Mocha;
+        addFile(file: string): Mocha;
+        reporter(value: string): Mocha;
+        ui(value: string): Mocha;
+        grep(value: string): Mocha;
+        grep(value: RegExp): Mocha;
+        invert(): Mocha;
+        ignoreLeaks(value: boolean): Mocha;
+        checkLeaks(): Mocha;
+        growl(): Mocha;
+        globals(value: string): Mocha;
+        globals(values: string[]): Mocha;
+        useColors(value: boolean): Mocha;
+        useInlineDiffs(value: boolean): Mocha;
+        timeout(value: number): Mocha;
+        slow(value: number): Mocha;
+        enableTimeouts(value: boolean): Mocha;
+        asyncOnly(value: boolean): Mocha;
+        noHighlighting(value: boolean): Mocha;
+
+        run(onComplete?: (failures: number) => void): void;
+    }
+
+    export = Mocha;
+}
diff --git a/typings/node/node.d.ts b/typings/node/node.d.ts
new file mode 100644
index 000000000..3760cd108
--- /dev/null
+++ b/typings/node/node.d.ts
@@ -0,0 +1,1454 @@
+// Type definitions for Node.js v0.12.0
+// Project: http://nodejs.org/
+// Definitions by: Microsoft TypeScript <http://typescriptlang.org>, DefinitelyTyped <https://github.com/borisyankov/DefinitelyTyped>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/************************************************
+*                                               *
+*               Node.js v0.12.0 API             *
+*                                               *
+************************************************/
+
+/************************************************
+*                                               *
+*                   GLOBAL                      *
+*                                               *
+************************************************/
+declare var process: NodeJS.Process;
+declare var global: any;
+
+declare var __filename: string;
+declare var __dirname: string;
+
+declare function setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;
+declare function clearTimeout(timeoutId: NodeJS.Timer): void;
+declare function setInterval(callback: (...args: any[]) => void, ms: number, ...args: any[]): NodeJS.Timer;
+declare function clearInterval(intervalId: NodeJS.Timer): void;
+declare function setImmediate(callback: (...args: any[]) => void, ...args: any[]): any;
+declare function clearImmediate(immediateId: any): void;
+
+declare var require: {
+    (id: string): any;
+    resolve(id:string): string;
+    cache: any;
+    extensions: any;
+    main: any;
+};
+
+declare var module: {
+    exports: any;
+    require(id: string): any;
+    id: string;
+    filename: string;
+    loaded: boolean;
+    parent: any;
+    children: any[];
+};
+
+// Same as module.exports
+declare var exports: any;
+declare var SlowBuffer: {
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (size: Uint8Array): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
+    isBuffer(obj: any): boolean;
+    byteLength(string: string, encoding?: string): number;
+    concat(list: Buffer[], totalLength?: number): Buffer;
+};
+
+
+// Buffer class
+interface Buffer extends NodeBuffer {}
+declare var Buffer: {
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (size: Uint8Array): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
+    isBuffer(obj: any): boolean;
+    byteLength(string: string, encoding?: string): number;
+    concat(list: Buffer[], totalLength?: number): Buffer;
+};
+
+/************************************************
+*                                               *
+*               GLOBAL INTERFACES               *
+*                                               *
+************************************************/
+declare module NodeJS {
+    export interface ErrnoException extends Error {
+        errno?: number;
+        code?: string;
+        path?: string;
+        syscall?: string;
+    }
+
+    export interface EventEmitter {
+        addListener(event: string, listener: Function): EventEmitter;
+        on(event: string, listener: Function): EventEmitter;
+        once(event: string, listener: Function): EventEmitter;
+        removeListener(event: string, listener: Function): EventEmitter;
+        removeAllListeners(event?: string): EventEmitter;
+        setMaxListeners(n: number): void;
+        listeners(event: string): Function[];
+        emit(event: string, ...args: any[]): boolean;
+    }
+
+    export interface ReadableStream extends EventEmitter {
+        readable: boolean;
+        read(size?: number): string|Buffer;
+        setEncoding(encoding: string): void;
+        pause(): void;
+        resume(): void;
+        pipe<T extends WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        unpipe<T extends WritableStream>(destination?: T): void;
+        unshift(chunk: string): void;
+        unshift(chunk: Buffer): void;
+        wrap(oldStream: ReadableStream): ReadableStream;
+    }
+
+    export interface WritableStream extends EventEmitter {
+        writable: boolean;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export interface ReadWriteStream extends ReadableStream, WritableStream {}
+
+    export interface Process extends EventEmitter {
+        stdout: WritableStream;
+        stderr: WritableStream;
+        stdin: ReadableStream;
+        argv: string[];
+        execPath: string;
+        abort(): void;
+        chdir(directory: string): void;
+        cwd(): string;
+        env: any;
+        exit(code?: number): void;
+        getgid(): number;
+        setgid(id: number): void;
+        setgid(id: string): void;
+        getuid(): number;
+        setuid(id: number): void;
+        setuid(id: string): void;
+        version: string;
+        versions: {
+            http_parser: string;
+            node: string;
+            v8: string;
+            ares: string;
+            uv: string;
+            zlib: string;
+            openssl: string;
+        };
+        config: {
+            target_defaults: {
+                cflags: any[];
+                default_configuration: string;
+                defines: string[];
+                include_dirs: string[];
+                libraries: string[];
+            };
+            variables: {
+                clang: number;
+                host_arch: string;
+                node_install_npm: boolean;
+                node_install_waf: boolean;
+                node_prefix: string;
+                node_shared_openssl: boolean;
+                node_shared_v8: boolean;
+                node_shared_zlib: boolean;
+                node_use_dtrace: boolean;
+                node_use_etw: boolean;
+                node_use_openssl: boolean;
+                target_arch: string;
+                v8_no_strict_aliasing: number;
+                v8_use_snapshot: boolean;
+                visibility: string;
+            };
+        };
+        kill(pid: number, signal?: string): void;
+        pid: number;
+        title: string;
+        arch: string;
+        platform: string;
+        memoryUsage(): { rss: number; heapTotal: number; heapUsed: number; };
+        nextTick(callback: Function): void;
+        umask(mask?: number): number;
+        uptime(): number;
+        hrtime(time?:number[]): number[];
+
+        // Worker
+        send?(message: any, sendHandle?: any): void;
+    }
+
+    export interface Timer {
+        ref() : void;
+        unref() : void;
+    }
+}
+
+/**
+ * @deprecated
+ */
+interface NodeBuffer {
+    [index: number]: number;
+    write(string: string, offset?: number, length?: number, encoding?: string): number;
+    toString(encoding?: string, start?: number, end?: number): string;
+    toJSON(): any;
+    length: number;
+    copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
+    slice(start?: number, end?: number): Buffer;
+    readUInt8(offset: number, noAsset?: boolean): number;
+    readUInt16LE(offset: number, noAssert?: boolean): number;
+    readUInt16BE(offset: number, noAssert?: boolean): number;
+    readUInt32LE(offset: number, noAssert?: boolean): number;
+    readUInt32BE(offset: number, noAssert?: boolean): number;
+    readInt8(offset: number, noAssert?: boolean): number;
+    readInt16LE(offset: number, noAssert?: boolean): number;
+    readInt16BE(offset: number, noAssert?: boolean): number;
+    readInt32LE(offset: number, noAssert?: boolean): number;
+    readInt32BE(offset: number, noAssert?: boolean): number;
+    readFloatLE(offset: number, noAssert?: boolean): number;
+    readFloatBE(offset: number, noAssert?: boolean): number;
+    readDoubleLE(offset: number, noAssert?: boolean): number;
+    readDoubleBE(offset: number, noAssert?: boolean): number;
+    writeUInt8(value: number, offset: number, noAssert?: boolean): void;
+    writeUInt16LE(value: number, offset: number, noAssert?: boolean): void;
+    writeUInt16BE(value: number, offset: number, noAssert?: boolean): void;
+    writeUInt32LE(value: number, offset: number, noAssert?: boolean): void;
+    writeUInt32BE(value: number, offset: number, noAssert?: boolean): void;
+    writeInt8(value: number, offset: number, noAssert?: boolean): void;
+    writeInt16LE(value: number, offset: number, noAssert?: boolean): void;
+    writeInt16BE(value: number, offset: number, noAssert?: boolean): void;
+    writeInt32LE(value: number, offset: number, noAssert?: boolean): void;
+    writeInt32BE(value: number, offset: number, noAssert?: boolean): void;
+    writeFloatLE(value: number, offset: number, noAssert?: boolean): void;
+    writeFloatBE(value: number, offset: number, noAssert?: boolean): void;
+    writeDoubleLE(value: number, offset: number, noAssert?: boolean): void;
+    writeDoubleBE(value: number, offset: number, noAssert?: boolean): void;
+    fill(value: any, offset?: number, end?: number): void;
+}
+
+/************************************************
+*                                               *
+*                   MODULES                     *
+*                                               *
+************************************************/
+declare module "buffer" {
+    export var INSPECT_MAX_BYTES: number;
+}
+
+declare module "querystring" {
+    export function stringify(obj: any, sep?: string, eq?: string): string;
+    export function parse(str: string, sep?: string, eq?: string, options?: { maxKeys?: number; }): any;
+    export function escape(str: string): string;
+    export function unescape(str: string): string;
+}
+
+declare module "events" {
+    export class EventEmitter implements NodeJS.EventEmitter {
+        static listenerCount(emitter: EventEmitter, event: string): number;
+
+        addListener(event: string, listener: Function): EventEmitter;
+        on(event: string, listener: Function): EventEmitter;
+        once(event: string, listener: Function): EventEmitter;
+        removeListener(event: string, listener: Function): EventEmitter;
+        removeAllListeners(event?: string): EventEmitter;
+        setMaxListeners(n: number): void;
+        listeners(event: string): Function[];
+        emit(event: string, ...args: any[]): boolean;
+   }
+}
+
+declare module "http" {
+    import events = require("events");
+    import net = require("net");
+    import stream = require("stream");
+
+    export interface Server extends events.EventEmitter {
+        listen(port: number, hostname?: string, backlog?: number, callback?: Function): Server;
+        listen(path: string, callback?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
+        close(cb?: any): Server;
+        address(): { port: number; family: string; address: string; };
+        maxHeadersCount: number;
+    }
+    /**
+     * @deprecated Use IncomingMessage
+     */
+    export interface ServerRequest extends IncomingMessage {
+        connection: net.Socket;
+    }
+    export interface ServerResponse extends events.EventEmitter, stream.Writable {
+        // Extended base methods
+        write(buffer: Buffer): boolean;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
+
+        writeContinue(): void;
+        writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
+        writeHead(statusCode: number, headers?: any): void;
+        statusCode: number;
+        setHeader(name: string, value: string): void;
+        sendDate: boolean;
+        getHeader(name: string): string;
+        removeHeader(name: string): void;
+        write(chunk: any, encoding?: string): any;
+        addTrailers(headers: any): void;
+
+        // Extended base methods
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
+    }
+    export interface ClientRequest extends events.EventEmitter, stream.Writable {
+        // Extended base methods
+        write(buffer: Buffer): boolean;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
+
+        write(chunk: any, encoding?: string): void;
+        abort(): void;
+        setTimeout(timeout: number, callback?: Function): void;
+        setNoDelay(noDelay?: boolean): void;
+        setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+
+        // Extended base methods
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
+    }
+    export interface IncomingMessage extends events.EventEmitter, stream.Readable {
+        httpVersion: string;
+        headers: any;
+        rawHeaders: string[];
+        trailers: any;
+        rawTrailers: any;
+        setTimeout(msecs: number, callback: Function): NodeJS.Timer;
+        /**
+         * Only valid for request obtained from http.Server.
+         */
+        method?: string;
+        /**
+         * Only valid for request obtained from http.Server.
+         */
+        url?: string;
+        /**
+         * Only valid for response obtained from http.ClientRequest.
+         */
+        statusCode?: number;
+        /**
+         * Only valid for response obtained from http.ClientRequest.
+         */
+        statusMessage?: string;
+        socket: net.Socket;
+    }
+    /**
+     * @deprecated Use IncomingMessage
+     */
+    export interface ClientResponse extends IncomingMessage { }
+
+	export interface AgentOptions {
+		/**
+		 * Keep sockets around in a pool to be used by other requests in the future. Default = false
+		 */
+		keepAlive?: boolean;
+		/**
+		 * When using HTTP KeepAlive, how often to send TCP KeepAlive packets over sockets being kept alive. Default = 1000.
+		 * Only relevant if keepAlive is set to true.
+		 */
+		keepAliveMsecs?: number;
+		/**
+		 * Maximum number of sockets to allow per host. Default for Node 0.10 is 5, default for Node 0.12 is Infinity
+		 */
+		maxSockets?: number;
+		/**
+		 * Maximum number of sockets to leave open in a free state. Only relevant if keepAlive is set to true. Default = 256.
+		 */
+		maxFreeSockets?: number;
+	}
+
+    export class Agent {
+		maxSockets: number;
+		sockets: any;
+		requests: any;
+
+		constructor(opts?: AgentOptions);
+
+		/**
+		 * Destroy any sockets that are currently in use by the agent.
+		 * It is usually not necessary to do this. However, if you are using an agent with KeepAlive enabled,
+		 * then it is best to explicitly shut down the agent when you know that it will no longer be used. Otherwise,
+		 * sockets may hang open for quite a long time before the server terminates them.
+		 */
+		destroy(): void;
+	}
+
+    export var STATUS_CODES: {
+        [errorCode: number]: string;
+        [errorCode: string]: string;
+    };
+    export function createServer(requestListener?: (request: IncomingMessage, response: ServerResponse) =>void ): Server;
+    export function createClient(port?: number, host?: string): any;
+    export function request(options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
+    export function get(options: any, callback?: (res: IncomingMessage) => void): ClientRequest;
+    export var globalAgent: Agent;
+}
+
+declare module "cluster" {
+    import child  = require("child_process");
+    import events = require("events");
+
+    export interface ClusterSettings {
+        exec?: string;
+        args?: string[];
+        silent?: boolean;
+    }
+
+    export class Worker extends events.EventEmitter {
+        id: string;
+        process: child.ChildProcess;
+        suicide: boolean;
+        send(message: any, sendHandle?: any): void;
+        kill(signal?: string): void;
+        destroy(signal?: string): void;
+        disconnect(): void;
+    }
+
+    export var settings: ClusterSettings;
+    export var isMaster: boolean;
+    export var isWorker: boolean;
+    export function setupMaster(settings?: ClusterSettings): void;
+    export function fork(env?: any): Worker;
+    export function disconnect(callback?: Function): void;
+    export var worker: Worker;
+    export var workers: Worker[];
+
+    // Event emitter
+    export function addListener(event: string, listener: Function): void;
+    export function on(event: string, listener: Function): any;
+    export function once(event: string, listener: Function): void;
+    export function removeListener(event: string, listener: Function): void;
+    export function removeAllListeners(event?: string): void;
+    export function setMaxListeners(n: number): void;
+    export function listeners(event: string): Function[];
+    export function emit(event: string, ...args: any[]): boolean;
+}
+
+declare module "zlib" {
+    import stream = require("stream");
+    export interface ZlibOptions { chunkSize?: number; windowBits?: number; level?: number; memLevel?: number; strategy?: number; dictionary?: any; }
+
+    export interface Gzip extends stream.Transform { }
+    export interface Gunzip extends stream.Transform { }
+    export interface Deflate extends stream.Transform { }
+    export interface Inflate extends stream.Transform { }
+    export interface DeflateRaw extends stream.Transform { }
+    export interface InflateRaw extends stream.Transform { }
+    export interface Unzip extends stream.Transform { }
+
+    export function createGzip(options?: ZlibOptions): Gzip;
+    export function createGunzip(options?: ZlibOptions): Gunzip;
+    export function createDeflate(options?: ZlibOptions): Deflate;
+    export function createInflate(options?: ZlibOptions): Inflate;
+    export function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
+    export function createInflateRaw(options?: ZlibOptions): InflateRaw;
+    export function createUnzip(options?: ZlibOptions): Unzip;
+
+    export function deflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function deflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function gzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function gunzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function inflate(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function inflateRaw(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+    export function unzip(buf: Buffer, callback: (error: Error, result: any) =>void ): void;
+
+    // Constants
+    export var Z_NO_FLUSH: number;
+    export var Z_PARTIAL_FLUSH: number;
+    export var Z_SYNC_FLUSH: number;
+    export var Z_FULL_FLUSH: number;
+    export var Z_FINISH: number;
+    export var Z_BLOCK: number;
+    export var Z_TREES: number;
+    export var Z_OK: number;
+    export var Z_STREAM_END: number;
+    export var Z_NEED_DICT: number;
+    export var Z_ERRNO: number;
+    export var Z_STREAM_ERROR: number;
+    export var Z_DATA_ERROR: number;
+    export var Z_MEM_ERROR: number;
+    export var Z_BUF_ERROR: number;
+    export var Z_VERSION_ERROR: number;
+    export var Z_NO_COMPRESSION: number;
+    export var Z_BEST_SPEED: number;
+    export var Z_BEST_COMPRESSION: number;
+    export var Z_DEFAULT_COMPRESSION: number;
+    export var Z_FILTERED: number;
+    export var Z_HUFFMAN_ONLY: number;
+    export var Z_RLE: number;
+    export var Z_FIXED: number;
+    export var Z_DEFAULT_STRATEGY: number;
+    export var Z_BINARY: number;
+    export var Z_TEXT: number;
+    export var Z_ASCII: number;
+    export var Z_UNKNOWN: number;
+    export var Z_DEFLATED: number;
+    export var Z_NULL: number;
+}
+
+declare module "os" {
+    export function tmpdir(): string;
+    export function hostname(): string;
+    export function type(): string;
+    export function platform(): string;
+    export function arch(): string;
+    export function release(): string;
+    export function uptime(): number;
+    export function loadavg(): number[];
+    export function totalmem(): number;
+    export function freemem(): number;
+    export function cpus(): { model: string; speed: number; times: { user: number; nice: number; sys: number; idle: number; irq: number; }; }[];
+    export function networkInterfaces(): any;
+    export var EOL: string;
+}
+
+declare module "https" {
+    import tls = require("tls");
+    import events = require("events");
+    import http = require("http");
+
+    export interface ServerOptions {
+        pfx?: any;
+        key?: any;
+        passphrase?: string;
+        cert?: any;
+        ca?: any;
+        crl?: any;
+        ciphers?: string;
+        honorCipherOrder?: boolean;
+        requestCert?: boolean;
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;
+        SNICallback?: (servername: string) => any;
+    }
+
+    export interface RequestOptions {
+        host?: string;
+        hostname?: string;
+        port?: number;
+        path?: string;
+        method?: string;
+        headers?: any;
+        auth?: string;
+        agent?: any;
+        pfx?: any;
+        key?: any;
+        passphrase?: string;
+        cert?: any;
+        ca?: any;
+        ciphers?: string;
+        rejectUnauthorized?: boolean;
+    }
+
+    export interface Agent {
+        maxSockets: number;
+        sockets: any;
+        requests: any;
+    }
+    export var Agent: {
+        new (options?: RequestOptions): Agent;
+    };
+    export interface Server extends tls.Server { }
+    export function createServer(options: ServerOptions, requestListener?: Function): Server;
+    export function request(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest;
+    export function get(options: RequestOptions, callback?: (res: http.IncomingMessage) =>void ): http.ClientRequest;
+    export var globalAgent: Agent;
+}
+
+declare module "punycode" {
+    export function decode(string: string): string;
+    export function encode(string: string): string;
+    export function toUnicode(domain: string): string;
+    export function toASCII(domain: string): string;
+    export var ucs2: ucs2;
+    interface ucs2 {
+        decode(string: string): string;
+        encode(codePoints: number[]): string;
+    }
+    export var version: any;
+}
+
+declare module "repl" {
+    import stream = require("stream");
+    import events = require("events");
+
+    export interface ReplOptions {
+        prompt?: string;
+        input?: NodeJS.ReadableStream;
+        output?: NodeJS.WritableStream;
+        terminal?: boolean;
+        eval?: Function;
+        useColors?: boolean;
+        useGlobal?: boolean;
+        ignoreUndefined?: boolean;
+        writer?: Function;
+    }
+    export function start(options: ReplOptions): events.EventEmitter;
+}
+
+declare module "readline" {
+    import events = require("events");
+    import stream = require("stream");
+
+    export interface ReadLine extends events.EventEmitter {
+        setPrompt(prompt: string, length: number): void;
+        prompt(preserveCursor?: boolean): void;
+        question(query: string, callback: Function): void;
+        pause(): void;
+        resume(): void;
+        close(): void;
+        write(data: any, key?: any): void;
+    }
+    export interface ReadLineOptions {
+        input: NodeJS.ReadableStream;
+        output: NodeJS.WritableStream;
+        completer?: Function;
+        terminal?: boolean;
+    }
+    export function createInterface(options: ReadLineOptions): ReadLine;
+}
+
+declare module "vm" {
+    export interface Context { }
+    export interface Script {
+        runInThisContext(): void;
+        runInNewContext(sandbox?: Context): void;
+    }
+    export function runInThisContext(code: string, filename?: string): void;
+    export function runInNewContext(code: string, sandbox?: Context, filename?: string): void;
+    export function runInContext(code: string, context: Context, filename?: string): void;
+    export function createContext(initSandbox?: Context): Context;
+    export function createScript(code: string, filename?: string): Script;
+}
+
+declare module "child_process" {
+    import events = require("events");
+    import stream = require("stream");
+
+    export interface ChildProcess extends events.EventEmitter {
+        stdin:  stream.Writable;
+        stdout: stream.Readable;
+        stderr: stream.Readable;
+        pid: number;
+        kill(signal?: string): void;
+        send(message: any, sendHandle?: any): void;
+        disconnect(): void;
+    }
+
+    export function spawn(command: string, args?: string[], options?: {
+        cwd?: string;
+        stdio?: any;
+        custom?: any;
+        env?: any;
+        detached?: boolean;
+    }): ChildProcess;
+    export function exec(command: string, options: {
+        cwd?: string;
+        stdio?: any;
+        customFds?: any;
+        env?: any;
+        encoding?: string;
+        timeout?: number;
+        maxBuffer?: number;
+        killSignal?: string;
+    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string,
+        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[],
+        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[], options?: {
+        cwd?: string;
+        stdio?: any;
+        customFds?: any;
+        env?: any;
+        encoding?: string;
+        timeout?: number;
+        maxBuffer?: string;
+        killSignal?: string;
+    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function fork(modulePath: string, args?: string[], options?: {
+        cwd?: string;
+        env?: any;
+        encoding?: string;
+    }): ChildProcess;
+    export function execSync(command: string, options?: {
+        cwd?: string;
+        input?: string|Buffer;
+        stdio?: any;
+        env?: any;
+        uid?: number;
+        gid?: number;
+        timeout?: number;
+        maxBuffer?: number;
+        killSignal?: string;
+        encoding?: string;
+    }): ChildProcess;
+    export function execFileSync(command: string, args?: string[], options?: {
+        cwd?: string;
+        input?: string|Buffer;
+        stdio?: any;
+        env?: any;
+        uid?: number;
+        gid?: number;
+        timeout?: number;
+        maxBuffer?: number;
+        killSignal?: string;
+        encoding?: string;
+    }): ChildProcess;
+}
+
+declare module "url" {
+    export interface Url {
+        href: string;
+        protocol: string;
+        auth: string;
+        hostname: string;
+        port: string;
+        host: string;
+        pathname: string;
+        search: string;
+        query: any; // string | Object
+        slashes: boolean;
+        hash?: string;
+        path?: string;
+    }
+
+    export interface UrlOptions {
+        protocol?: string;
+        auth?: string;
+        hostname?: string;
+        port?: string;
+        host?: string;
+        pathname?: string;
+        search?: string;
+        query?: any;
+        hash?: string;
+        path?: string;
+    }
+
+    export function parse(urlStr: string, parseQueryString?: boolean , slashesDenoteHost?: boolean ): Url;
+    export function format(url: UrlOptions): string;
+    export function resolve(from: string, to: string): string;
+}
+
+declare module "dns" {
+    export function lookup(domain: string, family: number, callback: (err: Error, address: string, family: number) =>void ): string;
+    export function lookup(domain: string, callback: (err: Error, address: string, family: number) =>void ): string;
+    export function resolve(domain: string, rrtype: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve4(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolve6(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveMx(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveTxt(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveSrv(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveNs(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function resolveCname(domain: string, callback: (err: Error, addresses: string[]) =>void ): string[];
+    export function reverse(ip: string, callback: (err: Error, domains: string[]) =>void ): string[];
+}
+
+declare module "net" {
+    import stream = require("stream");
+
+    export interface Socket extends stream.Duplex {
+        // Extended base methods
+        write(buffer: Buffer): boolean;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, fd?: string): boolean;
+
+        connect(port: number, host?: string, connectionListener?: Function): void;
+        connect(path: string, connectionListener?: Function): void;
+        bufferSize: number;
+        setEncoding(encoding?: string): void;
+        write(data: any, encoding?: string, callback?: Function): void;
+        destroy(): void;
+        pause(): void;
+        resume(): void;
+        setTimeout(timeout: number, callback?: Function): void;
+        setNoDelay(noDelay?: boolean): void;
+        setKeepAlive(enable?: boolean, initialDelay?: number): void;
+        address(): { port: number; family: string; address: string; };
+        unref(): void;
+        ref(): void;
+
+        remoteAddress: string;
+        remoteFamily: string;
+        remotePort: number;
+        localAddress: string;
+        localPort: number;
+        bytesRead: number;
+        bytesWritten: number;
+
+        // Extended base methods
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+        end(data?: any, encoding?: string): void;
+    }
+
+    export var Socket: {
+        new (options?: { fd?: string; type?: string; allowHalfOpen?: boolean; }): Socket;
+    };
+
+    export interface Server extends Socket {
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server;
+        listen(path: string, listeningListener?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
+        close(callback?: Function): Server;
+        address(): { port: number; family: string; address: string; };
+        maxConnections: number;
+        connections: number;
+    }
+    export function createServer(connectionListener?: (socket: Socket) =>void ): Server;
+    export function createServer(options?: { allowHalfOpen?: boolean; }, connectionListener?: (socket: Socket) =>void ): Server;
+    export function connect(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function connect(port: number, host?: string, connectionListener?: Function): Socket;
+    export function connect(path: string, connectionListener?: Function): Socket;
+    export function createConnection(options: { allowHalfOpen?: boolean; }, connectionListener?: Function): Socket;
+    export function createConnection(port: number, host?: string, connectionListener?: Function): Socket;
+    export function createConnection(path: string, connectionListener?: Function): Socket;
+    export function isIP(input: string): number;
+    export function isIPv4(input: string): boolean;
+    export function isIPv6(input: string): boolean;
+}
+
+declare module "dgram" {
+    import events = require("events");
+
+    interface RemoteInfo {
+        address: string;
+        port: number;
+        size: number;
+    }
+
+    interface AddressInfo {
+        address: string;
+        family: string;
+        port: number;
+    }
+
+    export function createSocket(type: string, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
+
+    interface Socket extends events.EventEmitter {
+        send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: (error: Error, bytes: number) => void): void;
+        bind(port: number, address?: string, callback?: () => void): void;
+        close(): void;
+        address(): AddressInfo;
+        setBroadcast(flag: boolean): void;
+        setMulticastTTL(ttl: number): void;
+        setMulticastLoopback(flag: boolean): void;
+        addMembership(multicastAddress: string, multicastInterface?: string): void;
+        dropMembership(multicastAddress: string, multicastInterface?: string): void;
+    }
+}
+
+declare module "fs" {
+    import stream = require("stream");
+    import events = require("events");
+
+    interface Stats {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isSymbolicLink(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+        dev: number;
+        ino: number;
+        mode: number;
+        nlink: number;
+        uid: number;
+        gid: number;
+        rdev: number;
+        size: number;
+        blksize: number;
+        blocks: number;
+        atime: Date;
+        mtime: Date;
+        ctime: Date;
+    }
+
+    interface FSWatcher extends events.EventEmitter {
+        close(): void;
+    }
+
+    export interface ReadStream extends stream.Readable {
+        close(): void;
+    }
+    export interface WriteStream extends stream.Writable {
+        close(): void;
+    }
+
+    export function rename(oldPath: string, newPath: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function renameSync(oldPath: string, newPath: string): void;
+    export function truncate(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function truncate(path: string, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function truncateSync(path: string, len?: number): void;
+    export function ftruncate(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function ftruncate(fd: number, len: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function ftruncateSync(fd: number, len?: number): void;
+    export function chown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function chownSync(path: string, uid: number, gid: number): void;
+    export function fchown(fd: number, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function fchownSync(fd: number, uid: number, gid: number): void;
+    export function lchown(path: string, uid: number, gid: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function lchownSync(path: string, uid: number, gid: number): void;
+    export function chmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function chmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function chmodSync(path: string, mode: number): void;
+    export function chmodSync(path: string, mode: string): void;
+    export function fchmod(fd: number, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function fchmod(fd: number, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function fchmodSync(fd: number, mode: number): void;
+    export function fchmodSync(fd: number, mode: string): void;
+    export function lchmod(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function lchmod(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function lchmodSync(path: string, mode: number): void;
+    export function lchmodSync(path: string, mode: string): void;
+    export function stat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
+    export function lstat(path: string, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
+    export function fstat(fd: number, callback?: (err: NodeJS.ErrnoException, stats: Stats) => any): void;
+    export function statSync(path: string): Stats;
+    export function lstatSync(path: string): Stats;
+    export function fstatSync(fd: number): Stats;
+    export function link(srcpath: string, dstpath: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function linkSync(srcpath: string, dstpath: string): void;
+    export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
+    export function readlink(path: string, callback?: (err: NodeJS.ErrnoException, linkString: string) => any): void;
+    export function readlinkSync(path: string): string;
+    export function realpath(path: string, callback?: (err: NodeJS.ErrnoException, resolvedPath: string) => any): void;
+    export function realpath(path: string, cache: {[path: string]: string}, callback: (err: NodeJS.ErrnoException, resolvedPath: string) =>any): void;
+    export function realpathSync(path: string, cache?: {[path: string]: string}): string;
+    export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function unlinkSync(path: string): void;
+    export function rmdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function rmdirSync(path: string): void;
+    export function mkdir(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function mkdir(path: string, mode: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function mkdir(path: string, mode: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function mkdirSync(path: string, mode?: number): void;
+    export function mkdirSync(path: string, mode?: string): void;
+    export function readdir(path: string, callback?: (err: NodeJS.ErrnoException, files: string[]) => void): void;
+    export function readdirSync(path: string): string[];
+    export function close(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function closeSync(fd: number): void;
+    export function open(path: string, flags: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void;
+    export function open(path: string, flags: string, mode: number, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void;
+    export function open(path: string, flags: string, mode: string, callback?: (err: NodeJS.ErrnoException, fd: number) => any): void;
+    export function openSync(path: string, flags: string, mode?: number): number;
+    export function openSync(path: string, flags: string, mode?: string): number;
+    export function utimes(path: string, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function utimes(path: string, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function utimesSync(path: string, atime: number, mtime: number): void;
+    export function utimesSync(path: string, atime: Date, mtime: Date): void;
+    export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function futimes(fd: number, atime: Date, mtime: Date, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function futimesSync(fd: number, atime: number, mtime: number): void;
+    export function futimesSync(fd: number, atime: Date, mtime: Date): void;
+    export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
+    export function fsyncSync(fd: number): void;
+    export function write(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, written: number, buffer: Buffer) => void): void;
+    export function writeSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
+    export function read(fd: number, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: NodeJS.ErrnoException, bytesRead: number, buffer: Buffer) => void): void;
+    export function readSync(fd: number, buffer: Buffer, offset: number, length: number, position: number): number;
+    export function readFile(filename: string, encoding: string, callback: (err: NodeJS.ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: NodeJS.ErrnoException, data: string) => void): void;
+    export function readFile(filename: string, options: { flag?: string; }, callback: (err: NodeJS.ErrnoException, data: Buffer) => void): void;
+    export function readFile(filename: string, callback: (err: NodeJS.ErrnoException, data: Buffer) => void ): void;
+    export function readFileSync(filename: string, encoding: string): string;
+    export function readFileSync(filename: string, options: { encoding: string; flag?: string; }): string;
+    export function readFileSync(filename: string, options?: { flag?: string; }): Buffer;
+    export function writeFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    export function writeFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function appendFile(filename: string, data: any, callback?: (err: NodeJS.ErrnoException) => void): void;
+    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: number; flag?: string; }): void;
+    export function appendFileSync(filename: string, data: any, options?: { encoding?: string; mode?: string; flag?: string; }): void;
+    export function watchFile(filename: string, listener: (curr: Stats, prev: Stats) => void): void;
+    export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: (curr: Stats, prev: Stats) => void): void;
+    export function unwatchFile(filename: string, listener?: (curr: Stats, prev: Stats) => void): void;
+    export function watch(filename: string, listener?: (event: string, filename: string) => any): FSWatcher;
+    export function watch(filename: string, options: { persistent?: boolean; }, listener?: (event: string, filename: string) => any): FSWatcher;
+    export function exists(path: string, callback?: (exists: boolean) => void): void;
+    export function existsSync(path: string): boolean;
+    export function createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        fd?: string;
+        mode?: number;
+        bufferSize?: number;
+    }): ReadStream;
+    export function createReadStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        fd?: string;
+        mode?: string;
+        bufferSize?: number;
+    }): ReadStream;
+    export function createWriteStream(path: string, options?: {
+        flags?: string;
+        encoding?: string;
+        string?: string;
+    }): WriteStream;
+}
+
+declare module "path" {
+
+    export interface ParsedPath {
+        root: string;
+        dir: string;
+        base: string;
+        ext: string;
+        name: string;
+    }
+
+    export function normalize(p: string): string;
+    export function join(...paths: any[]): string;
+    export function resolve(...pathSegments: any[]): string;
+    export function isAbsolute(p: string): boolean;
+    export function relative(from: string, to: string): string;
+    export function dirname(p: string): string;
+    export function basename(p: string, ext?: string): string;
+    export function extname(p: string): string;
+    export var sep: string;
+    export var delimiter: string;
+    export function parse(p: string): ParsedPath;
+    export function format(pP: ParsedPath): string;
+
+    export module posix {
+      export function normalize(p: string): string;
+      export function join(...paths: any[]): string;
+      export function resolve(...pathSegments: any[]): string;
+      export function isAbsolute(p: string): boolean;
+      export function relative(from: string, to: string): string;
+      export function dirname(p: string): string;
+      export function basename(p: string, ext?: string): string;
+      export function extname(p: string): string;
+      export var sep: string;
+      export var delimiter: string;
+      export function parse(p: string): ParsedPath;
+      export function format(pP: ParsedPath): string;
+    }
+
+    export module win32 {
+      export function normalize(p: string): string;
+      export function join(...paths: any[]): string;
+      export function resolve(...pathSegments: any[]): string;
+      export function isAbsolute(p: string): boolean;
+      export function relative(from: string, to: string): string;
+      export function dirname(p: string): string;
+      export function basename(p: string, ext?: string): string;
+      export function extname(p: string): string;
+      export var sep: string;
+      export var delimiter: string;
+      export function parse(p: string): ParsedPath;
+      export function format(pP: ParsedPath): string;
+    }
+}
+
+declare module "string_decoder" {
+    export interface NodeStringDecoder {
+        write(buffer: Buffer): string;
+        detectIncompleteChar(buffer: Buffer): number;
+    }
+    export var StringDecoder: {
+        new (encoding: string): NodeStringDecoder;
+    };
+}
+
+declare module "tls" {
+    import crypto = require("crypto");
+    import net = require("net");
+    import stream = require("stream");
+
+    var CLIENT_RENEG_LIMIT: number;
+    var CLIENT_RENEG_WINDOW: number;
+
+    export interface TlsOptions {
+        pfx?: any;   //string or buffer
+        key?: any;   //string or buffer
+        passphrase?: string;
+        cert?: any;
+        ca?: any;    //string or buffer
+        crl?: any;   //string or string array
+        ciphers?: string;
+        honorCipherOrder?: any;
+        requestCert?: boolean;
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;  //array or Buffer;
+        SNICallback?: (servername: string) => any;
+    }
+
+    export interface ConnectionOptions {
+        host?: string;
+        port?: number;
+        socket?: net.Socket;
+        pfx?: any;   //string | Buffer
+        key?: any;   //string | Buffer
+        passphrase?: string;
+        cert?: any;  //string | Buffer
+        ca?: any;    //Array of string | Buffer
+        rejectUnauthorized?: boolean;
+        NPNProtocols?: any;  //Array of string | Buffer
+        servername?: string;
+    }
+
+    export interface Server extends net.Server {
+        // Extended base methods
+        listen(port: number, host?: string, backlog?: number, listeningListener?: Function): Server;
+        listen(path: string, listeningListener?: Function): Server;
+        listen(handle: any, listeningListener?: Function): Server;
+
+        listen(port: number, host?: string, callback?: Function): Server;
+        close(): Server;
+        address(): { port: number; family: string; address: string; };
+        addContext(hostName: string, credentials: {
+            key: string;
+            cert: string;
+            ca: string;
+        }): void;
+        maxConnections: number;
+        connections: number;
+    }
+
+    export interface ClearTextStream extends stream.Duplex {
+        authorized: boolean;
+        authorizationError: Error;
+        getPeerCertificate(): any;
+        getCipher: {
+            name: string;
+            version: string;
+        };
+        address: {
+            port: number;
+            family: string;
+            address: string;
+        };
+        remoteAddress: string;
+        remotePort: number;
+    }
+
+    export interface SecurePair {
+        encrypted: any;
+        cleartext: any;
+    }
+
+    export function createServer(options: TlsOptions, secureConnectionListener?: (cleartextStream: ClearTextStream) =>void ): Server;
+    export function connect(options: TlsOptions, secureConnectionListener?: () =>void ): ClearTextStream;
+    export function connect(port: number, host?: string, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+    export function connect(port: number, options?: ConnectionOptions, secureConnectListener?: () =>void ): ClearTextStream;
+    export function createSecurePair(credentials?: crypto.Credentials, isServer?: boolean, requestCert?: boolean, rejectUnauthorized?: boolean): SecurePair;
+}
+
+declare module "crypto" {
+    export interface CredentialDetails {
+        pfx: string;
+        key: string;
+        passphrase: string;
+        cert: string;
+        ca: any;    //string | string array
+        crl: any;   //string | string array
+        ciphers: string;
+    }
+    export interface Credentials { context?: any; }
+    export function createCredentials(details: CredentialDetails): Credentials;
+    export function createHash(algorithm: string): Hash;
+    export function createHmac(algorithm: string, key: string): Hmac;
+    export function createHmac(algorithm: string, key: Buffer): Hmac;
+    interface Hash {
+        update(data: any, input_encoding?: string): Hash;
+        digest(encoding: 'buffer'): Buffer;
+        digest(encoding: string): any;
+        digest(): Buffer;
+    }
+    interface Hmac {
+        update(data: any, input_encoding?: string): Hmac;
+        digest(encoding: 'buffer'): Buffer;
+        digest(encoding: string): any;
+        digest(): Buffer;
+    }
+    export function createCipher(algorithm: string, password: any): Cipher;
+    export function createCipheriv(algorithm: string, key: any, iv: any): Cipher;
+    interface Cipher {
+        update(data: Buffer): Buffer;
+        update(data: string, input_encoding?: string, output_encoding?: string): string;
+        final(): Buffer;
+        final(output_encoding: string): string;
+        setAutoPadding(auto_padding: boolean): void;
+    }
+    export function createDecipher(algorithm: string, password: any): Decipher;
+    export function createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
+    interface Decipher {
+        update(data: Buffer): Buffer;
+        update(data: string, input_encoding?: string, output_encoding?: string): string;
+        final(): Buffer;
+        final(output_encoding: string): string;
+        setAutoPadding(auto_padding: boolean): void;
+    }
+    export function createSign(algorithm: string): Signer;
+    interface Signer {
+        update(data: any): void;
+        sign(private_key: string, output_format: string): string;
+    }
+    export function createVerify(algorith: string): Verify;
+    interface Verify {
+        update(data: any): void;
+        verify(object: string, signature: string, signature_format?: string): boolean;
+    }
+    export function createDiffieHellman(prime_length: number): DiffieHellman;
+    export function createDiffieHellman(prime: number, encoding?: string): DiffieHellman;
+    interface DiffieHellman {
+        generateKeys(encoding?: string): string;
+        computeSecret(other_public_key: string, input_encoding?: string, output_encoding?: string): string;
+        getPrime(encoding?: string): string;
+        getGenerator(encoding: string): string;
+        getPublicKey(encoding?: string): string;
+        getPrivateKey(encoding?: string): string;
+        setPublicKey(public_key: string, encoding?: string): void;
+        setPrivateKey(public_key: string, encoding?: string): void;
+    }
+    export function getDiffieHellman(group_name: string): DiffieHellman;
+    export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: Buffer) => any): void;
+    export function pbkdf2Sync(password: string, salt: string, iterations: number, keylen: number) : Buffer;
+    export function randomBytes(size: number): Buffer;
+    export function randomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void;
+    export function pseudoRandomBytes(size: number): Buffer;
+    export function pseudoRandomBytes(size: number, callback: (err: Error, buf: Buffer) =>void ): void;
+}
+
+declare module "stream" {
+    import events = require("events");
+
+    export interface Stream extends events.EventEmitter {
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
+    }
+
+    export interface ReadableOptions {
+        highWaterMark?: number;
+        encoding?: string;
+        objectMode?: boolean;
+    }
+
+    export class Readable extends events.EventEmitter implements NodeJS.ReadableStream {
+        readable: boolean;
+        constructor(opts?: ReadableOptions);
+        _read(size: number): void;
+        read(size?: number): string|Buffer;
+        setEncoding(encoding: string): void;
+        pause(): void;
+        resume(): void;
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
+        unshift(chunk: string): void;
+        unshift(chunk: Buffer): void;
+        wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
+        push(chunk: any, encoding?: string): boolean;
+    }
+
+    export interface WritableOptions {
+        highWaterMark?: number;
+        decodeStrings?: boolean;
+    }
+
+    export class Writable extends events.EventEmitter implements NodeJS.WritableStream {
+        writable: boolean;
+        constructor(opts?: WritableOptions);
+        _write(data: Buffer, encoding: string, callback: Function): void;
+        _write(data: string, encoding: string, callback: Function): void;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export interface DuplexOptions extends ReadableOptions, WritableOptions {
+        allowHalfOpen?: boolean;
+    }
+
+    // Note: Duplex extends both Readable and Writable.
+    export class Duplex extends Readable implements NodeJS.ReadWriteStream {
+        writable: boolean;
+        constructor(opts?: DuplexOptions);
+        _write(data: Buffer, encoding: string, callback: Function): void;
+        _write(data: string, encoding: string, callback: Function): void;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export interface TransformOptions extends ReadableOptions, WritableOptions {}
+
+    // Note: Transform lacks the _read and _write methods of Readable/Writable.
+    export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {
+        readable: boolean;
+        writable: boolean;
+        constructor(opts?: TransformOptions);
+        _transform(chunk: Buffer, encoding: string, callback: Function): void;
+        _transform(chunk: string, encoding: string, callback: Function): void;
+        _flush(callback: Function): void;
+        read(size?: number): any;
+        setEncoding(encoding: string): void;
+        pause(): void;
+        resume(): void;
+        pipe<T extends NodeJS.WritableStream>(destination: T, options?: { end?: boolean; }): T;
+        unpipe<T extends NodeJS.WritableStream>(destination?: T): void;
+        unshift(chunk: string): void;
+        unshift(chunk: Buffer): void;
+        wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
+        push(chunk: any, encoding?: string): boolean;
+        write(buffer: Buffer, cb?: Function): boolean;
+        write(str: string, cb?: Function): boolean;
+        write(str: string, encoding?: string, cb?: Function): boolean;
+        end(): void;
+        end(buffer: Buffer, cb?: Function): void;
+        end(str: string, cb?: Function): void;
+        end(str: string, encoding?: string, cb?: Function): void;
+    }
+
+    export class PassThrough extends Transform {}
+}
+
+declare module "util" {
+    export interface InspectOptions {
+        showHidden?: boolean;
+        depth?: number;
+        colors?: boolean;
+        customInspect?: boolean;
+    }
+
+    export function format(format: any, ...param: any[]): string;
+    export function debug(string: string): void;
+    export function error(...param: any[]): void;
+    export function puts(...param: any[]): void;
+    export function print(...param: any[]): void;
+    export function log(string: string): void;
+    export function inspect(object: any, showHidden?: boolean, depth?: number, color?: boolean): string;
+    export function inspect(object: any, options: InspectOptions): string;
+    export function isArray(object: any): boolean;
+    export function isRegExp(object: any): boolean;
+    export function isDate(object: any): boolean;
+    export function isError(object: any): boolean;
+    export function inherits(constructor: any, superConstructor: any): void;
+}
+
+declare module "assert" {
+    function internal (value: any, message?: string): void;
+    module internal {
+        export class AssertionError implements Error {
+            name: string;
+            message: string;
+            actual: any;
+            expected: any;
+            operator: string;
+            generatedMessage: boolean;
+
+            constructor(options?: {message?: string; actual?: any; expected?: any;
+                                  operator?: string; stackStartFunction?: Function});
+        }
+
+        export function fail(actual?: any, expected?: any, message?: string, operator?: string): void;
+        export function ok(value: any, message?: string): void;
+        export function equal(actual: any, expected: any, message?: string): void;
+        export function notEqual(actual: any, expected: any, message?: string): void;
+        export function deepEqual(actual: any, expected: any, message?: string): void;
+        export function notDeepEqual(acutal: any, expected: any, message?: string): void;
+        export function strictEqual(actual: any, expected: any, message?: string): void;
+        export function notStrictEqual(actual: any, expected: any, message?: string): void;
+        export var throws: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        };
+
+        export var doesNotThrow: {
+            (block: Function, message?: string): void;
+            (block: Function, error: Function, message?: string): void;
+            (block: Function, error: RegExp, message?: string): void;
+            (block: Function, error: (err: any) => boolean, message?: string): void;
+        };
+
+        export function ifError(value: any): void;
+    }
+
+    export = internal;
+}
+
+declare module "tty" {
+    import net = require("net");
+
+    export function isatty(fd: number): boolean;
+    export interface ReadStream extends net.Socket {
+        isRaw: boolean;
+        setRawMode(mode: boolean): void;
+    }
+    export interface WriteStream extends net.Socket {
+        columns: number;
+        rows: number;
+    }
+}
+
+declare module "domain" {
+    import events = require("events");
+
+    export class Domain extends events.EventEmitter {
+        run(fn: Function): void;
+        add(emitter: events.EventEmitter): void;
+        remove(emitter: events.EventEmitter): void;
+        bind(cb: (err: Error, data: any) => any): any;
+        intercept(cb: (data: any) => any): any;
+        dispose(): void;
+
+        addListener(event: string, listener: Function): Domain;
+        on(event: string, listener: Function): Domain;
+        once(event: string, listener: Function): Domain;
+        removeListener(event: string, listener: Function): Domain;
+        removeAllListeners(event?: string): Domain;
+    }
+
+    export function create(): Domain;
+}
diff --git a/typings/source-map-support/source-map-support.d.ts b/typings/source-map-support/source-map-support.d.ts
new file mode 100644
index 000000000..31a642042
--- /dev/null
+++ b/typings/source-map-support/source-map-support.d.ts
@@ -0,0 +1,43 @@
+// Type definitions for source-map-support 0.2.10
+// Project: https://github.com/evanw/source-map-support
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module 'source-map-support' {
+	/**
+	 * Output of retrieveSourceMap().
+	 */
+	export interface UrlAndMap {
+		url: string;
+		map: string|Buffer;
+	}
+
+	/**
+	 * Options to install().
+	 */
+	export interface Options {
+		handleUncaughtExceptions?: boolean;
+		emptyCacheBetweenOperations?: boolean;
+		retrieveFile?: (path: string) => string;
+		retrieveSourceMap?: (source: string) => UrlAndMap;
+	}
+
+	export interface Position {
+		source: string;
+		line: number;
+		column: number;
+	}
+
+	export function wrapCallSite(frame: any /* StackFrame */): any /* StackFrame */;
+	export function getErrorSource(error: Error): string;
+	export function mapSourcePosition(position: Position): Position;
+	export function retrieveSourceMap(source: string): UrlAndMap;
+
+	/**
+	 * Install SourceMap support.
+	 * @param options Can be used to e.g. disable uncaughtException handler.
+	 */
+	export function install(options?: Options): void;
+}
diff --git a/typings/tsd.d.ts b/typings/tsd.d.ts
new file mode 100644
index 000000000..ba52234cb
--- /dev/null
+++ b/typings/tsd.d.ts
@@ -0,0 +1,7 @@
+/// <reference path="chai/chai.d.ts" />
+/// <reference path="mocha/mocha.d.ts" />
+/// <reference path="node/node.d.ts" />
+/// <reference path="../node_modules/typescript/bin/typescript.d.ts" />
+/// <reference path="../node_modules/tsconfig/tsconfig.d.ts" />
+/// <reference path="source-map-support/source-map-support.d.ts" />
+/// <reference path="commander/commander.d.ts" />