Move project to GitHub and hide Telegram config

.gitignore

@@ -0,0 +1,2 @@
+node_modules/
+release/

LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Chris Kaczor
+
+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.

README.md

@@ -0,0 +1,11 @@
+# LaundryMonitor
+
+Monitors washing machine and dryer status.
+
+## Authors
+
+* **Chris Kaczor** - *Initial work* - https://github.com/ckaczor - https://chriskaczor.com
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE.md](LICENSE.md) file for details.

app/config.d.ts

@@ -0,0 +1,13 @@
+export interface IConfig {
+	port: number;
+	refreshInterval: number;
+	deviceDebounceInterval: number;
+	
+	botToken: string;
+	
+	chatId: string;
+	debugChatId: string;
+	
+	debug: boolean;
+	enableTelegram: boolean;
+}

app/config.ts

@@ -0,0 +1,17 @@
+import { IConfig } from './config.d';
+
+class Config implements IConfig {
+	port = 80;
+	refreshInterval = 500;
+	deviceDebounceInterval = 10000;
+	
+	botToken = 'BOT-TOKEN';
+	
+	chatId = 'CHAT-ID';
+	debugChatId = 'DEBUG-CHAT-ID';
+	
+	debug = false;
+	enableTelegram = true;
+}
+
+export const config = new Config();

app/device.ts

@@ -0,0 +1,100 @@
+import _ = require('underscore');
+import bunyan = require('bunyan');
+import gpio = require('onoff');
+
+export var log: bunyan.Logger;
+
+export class DeviceConfiguration {
+    key: string;
+    pin: number;
+}
+
+export class DeviceListConfiguration {
+    pollInterval: number;
+    deviceConfiguration: Array<DeviceConfiguration>;
+    deviceUpdateCallback: (device: Device, initialUpdate: boolean) => void;
+}
+
+export class DeviceList {
+    private deviceList: { [key: string]: Device };
+
+    constructor(private configuration: DeviceListConfiguration) {
+        this.deviceList = {};
+
+        configuration.deviceConfiguration.forEach((deviceConfiguration: DeviceConfiguration) => {
+            this.createDevice(deviceConfiguration.key, deviceConfiguration.pin);
+        });
+
+        this.update(true);
+
+        setInterval(this.update.bind(this), configuration.pollInterval);
+    }
+
+    private createDevice(key: string, pin: number): Device {
+        const device = new Device(key, pin);
+
+        this.deviceList[key] = device;
+
+        return device;
+    }
+
+    getDevices(): Array<Device> {
+        return _.toArray<Device>(this.deviceList);
+    }
+
+    getStatus(): any {
+        var status: { [key: string]: boolean } = {};
+
+        _.each(this.deviceList, (device: Device) => {
+            status[device.key] = device.value;
+        });
+
+        return status;
+    }
+
+    private update(initialUpdate: boolean = false) {
+        _.each(this.deviceList, (device: Device) => {
+            var deviceChanged = device.update();
+
+            if (deviceChanged) {
+                this.configuration.deviceUpdateCallback(device, initialUpdate);
+
+                if (log) {
+                    log.info(`DeviceList.Update - ${device.toString()}`);
+                }
+            }
+        });
+    }
+}
+
+export class Device {
+    private gpioPin: gpio.Gpio;
+
+    value: boolean;
+
+    constructor(public key: string, pin: number) {
+        this.gpioPin = new gpio.Gpio(pin, 'in', 'both');
+    }
+
+    toString(): string {
+        return `Device: ${this.key} = ${this.value}`;
+    }
+
+    getStatus(): any {
+        const status: { [key: string]: boolean } = {};
+
+        status[this.key] = this.value;
+
+        return status;
+    }
+
+    update(): boolean {
+        const newValue = this.gpioPin.readSync() === 0;
+
+        const changed = (this.value !== newValue);
+
+        this.value = newValue;
+
+        return changed;
+    }
+}

app/main.ts

@@ -0,0 +1,164 @@
+/// <reference path="../typings/express/express.d.ts" />
+/// <reference path="../typings/onoff/onoff.d.ts" />
+/// <reference path="../typings/request/request.d.ts" />
+/// <reference path="../typings/tsd.d.ts" />
+
+// ---
+
+import os = require('os');
+import bunyan = require('bunyan');
+import express = require('express');
+import http = require('http');
+import socketio = require('socket.io');
+import request = require('request');
+
+import device = require('./device');
+import Device = device.Device;
+
+import config = require('./config');
+import Config = config.config;
+
+var app = express();
+var server = http.createServer(app);
+var io = socketio(server);
+
+// ---
+
+var log = bunyan.createLogger({
+    name: 'laundry_monitor',
+    streams: [
+        {
+            type: 'rotating-file',
+            path: '/var/log/laundry_monitor.log',
+            period: '1d',
+            count: 3
+        },
+        {
+            stream: process.stdout
+        }
+    ]
+});
+
+device.log = log;
+
+// ---
+
+log.info('Setting up devices');
+
+var deviceListConfiguration: device.DeviceListConfiguration = {
+    pollInterval: Config.refreshInterval,
+    deviceConfiguration: [{ key: 'washer', pin: 413 }, { key: 'dryer', pin: 415 }],
+    deviceUpdateCallback: (device: Device, initialUpdate: boolean) => {
+        if (initialUpdate) {
+            return;
+        }
+
+        queueDeviceUpdate(device, undefined, 'The {name} is now {status}.');
+    }
+};
+
+var devices = new device.DeviceList(deviceListConfiguration);
+
+// ---
+
+const deviceLastState: { [key: string]: boolean } = {};
+const deviceUpdateQueue: { [key: string]: number } = {};
+
+function queueDeviceUpdate(device: Device, header: string, deviceTemplate: string) {
+    if (deviceUpdateQueue[device.key]) {
+        log.info(`queueDeviceUpdate - Stopping old timer for device: ${device.key}`);
+        clearTimeout(deviceUpdateQueue[device.key]);
+    }
+
+    log.info(`queueDeviceUpdate - Starting new timer for device: ${device.key}`);
+
+    deviceUpdateQueue[device.key] = setTimeout(() => {
+        if (deviceLastState[device.key] !== device.value) {
+            sendTelegramDeviceUpdate([device], header, deviceTemplate);
+            emitStatus(device.getStatus());
+        } else {
+            log.info(`queueDeviceUpdate - No change for device: ${device.key}`);
+        }
+
+        delete deviceUpdateQueue[device.key];
+    }, Config.deviceDebounceInterval) as any;
+}
+
+function sendTelegramDeviceUpdate(devices: Array<Device>, header: string, deviceTemplate: string) {
+    let telegramMessage = header || '';
+
+    devices.forEach((device: Device) => {
+        deviceLastState[device.key] = device.value;
+
+        const deviceLine = deviceTemplate.replace('{name}', device.key).replace('{status}', device.value ? 'ON' : 'OFF');
+
+        telegramMessage += `${deviceLine}\n`;
+    });
+
+    if (telegramMessage.length > 0) {
+        sendTelegramMessage(telegramMessage);
+    }
+}
+
+function sendTelegramMessage(message: string) {
+    log.info(`Telegram message: ${message}`);
+
+    if (!Config.enableTelegram) {
+        return;
+    }
+
+    const sendChatId = Config.debug ? Config.debugChatId : Config.chatId;
+
+    const url = `https://api.telegram.org/bot${Config.botToken}/sendMessage?chat_id=${sendChatId}&text=${encodeURIComponent(message)}`;
+
+    request(url);
+}
+
+// ---
+
+log.info('Starting web server');
+
+app.get('/getStatus', (request, response) => {
+    const data = devices.getStatus();
+
+    response.end(JSON.stringify(data));
+});
+
+server.listen(Config.port, () => {
+    const host = os.hostname();
+
+    log.info(`Listening at http://${host}:${Config.port}`);
+});
+
+// ---
+
+log.info('Starting socket.io server');
+
+function emitStatus(status: any) {
+    const socketMessage = JSON.stringify(status);
+
+    log.info(`emitStatus: ${socketMessage}`);
+
+    io.emit('status', socketMessage);
+}
+
+io.on('connection', (socket: SocketIO.Socket) => {
+    log.info('socket.io: connection');
+
+    socket.on('getStatus', () => {
+        log.info('socket.io: getStatus');
+
+        emitStatus(devices.getStatus());
+    });
+
+    socket.on('disconnect', () => {
+        log.info('socket.io: disconnect');
+    });
+});
+
+// ---
+
+log.info('Ready');
+
+emitStatus(devices.getStatus());
+sendTelegramDeviceUpdate(devices.getDevices(), 'Powering up!\n\n', 'The {name} is currently {status}.');

gulpfile.js

@@ -0,0 +1,44 @@
+var gulp = require('gulp');
+var ts = require('gulp-typescript');
+var merge = require('merge2');
+var runSequence = require('run-sequence');
+var dirSync = require('gulp-directory-sync');
+
+gulp.task('transpile', function () {
+    var tsResult = gulp.src('app/*.ts')
+        .pipe(ts({
+            declarationFiles: false,
+            noResolve: false,
+            noImplicitAny: true,
+            module: 'commonjs',
+            moduleResolution: 'node',
+            outDir: 'release'
+        }));
+
+    return merge([
+        tsResult.dts.pipe(gulp.dest('release/definitions')),
+        tsResult.js.pipe(gulp.dest('release'))
+    ]);
+});
+
+gulp.task('watch', function () {
+    gulp.watch(['app/**/*', 'scripts/**/*'], ['build']);
+});
+
+gulp.task('deploy', function () {
+    return gulp.src('')
+        .pipe(dirSync('release', '/mnt/chip/laundry_monitor', { printSummary: true, ignore: ['node_modules', '.foreverignore'] }))
+        .on('error', function () { });
+});
+
+gulp.task('package', function () {
+    gulp.src('package.json').pipe(gulp.dest('release'));
+    gulp.src('scripts/*.sh').pipe(gulp.dest('release'));
+    gulp.src('app/index.html').pipe(gulp.dest('release'));
+});
+
+gulp.task('build', function (done) {
+    runSequence('transpile', 'package', 'deploy', function () {
+        done();
+    });
+});

package.json

@@ -0,0 +1,27 @@
+{
+  "name": "laundry-monitor",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Chris Kaczor",
+  "license": "ISC",
+  "devDependencies": {
+    "gulp": "^3.9.1",
+    "gulp-directory-sync": "^1.2.3",
+    "gulp-typescript": "^3.1.2",
+    "merge2": "^1.0.2",
+    "run-sequence": "^1.2.2",
+    "typescript": "^2.0.9"
+  },
+  "dependencies": {
+    "bunyan": "^1.8.4",
+    "express": "^4.14.0",
+    "onoff": "^1.1.1",
+    "request": "^2.78.0",
+    "socket.io": "^1.5.1",
+    "underscore": "^1.8.3"
+  }
+}

scripts/debug.sh

@@ -0,0 +1,2 @@
+touch /home/ckaczor/laundry_monitor/.foreverignore
+sudo forever --minUptime 1000 --spinSleepTime 1000 --watch --watchIgnore *.html --watchDirectory /home/ckaczor/laundry_monitor /home/ckaczor/laundry_monitor/main.js | bunyan

scripts/start.sh

@@ -0,0 +1,2 @@
+touch /home/ckaczor/laundry_monitor/.foreverignore
+sudo forever start --minUptime 1000 --spinSleepTime 1000 --watch --watchIgnore *.html --watchDirectory /home/ckaczor/laundry_monitor /home/ckaczor/laundry_monitor/main.js > /dev/null

tsconfig.json

@@ -0,0 +1,7 @@
+{
+    "compilerOptions": {
+        "target": "es5",
+        "module": "commonjs",
+        "sourceMap": true
+    }
+}

tsd.json

@@ -0,0 +1,39 @@
+{
+  "version": "v4",
+  "repo": "borisyankov/DefinitelyTyped",
+  "ref": "master",
+  "path": "typings",
+  "bundle": "typings/tsd.d.ts",
+  "installed": {
+    "node/node.d.ts": {
+      "commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
+    },
+    "socket.io/socket.io.d.ts": {
+      "commit": "7fffbd3e040a93c244777e3be04cd6223ac69301"
+    },
+    "bunyan/bunyan.d.ts": {
+      "commit": "7fffbd3e040a93c244777e3be04cd6223ac69301"
+    },
+    "express/express.d.ts": {
+      "commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
+    },
+    "mime/mime.d.ts": {
+      "commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
+    },
+    "serve-static/serve-static.d.ts": {
+      "commit": "7b3d5a6ea5acda4a81f71309f1cc62354e63b681"
+    },
+    "underscore/underscore.d.ts": {
+      "commit": "86dbea8fc37d9473fee465da4f0a21bea4f8cbd9"
+    },
+    "onoff/onoff.d.ts": {
+      "commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
+    },
+    "request/request.d.ts": {
+      "commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
+    },
+    "form-data/form-data.d.ts": {
+      "commit": "f5ab2df94e1aabf0fc6d783ad01c4c4671760627"
+    }
+  }
+}

tslint.json

@@ -0,0 +1,56 @@
+{
+    "rules": {
+        "class-name": true,
+        "comment-format": [
+            true,
+            "check-space"
+        ],
+        "indent": [
+            true,
+            "tabs"
+        ],
+        "no-duplicate-variable": true,
+        "no-eval": true,
+        "no-internal-module": false,
+        "no-trailing-whitespace": false,
+        "no-var-keyword": true,
+        "one-line": [
+            true,
+            "check-open-brace",
+            "check-whitespace"
+        ],
+        "quotemark": [
+            true,
+            "single"
+        ],
+        "semicolon": [
+            true
+        ],
+        "triple-equals": [
+            true,
+            "allow-null-check"
+        ],
+        "typedef-whitespace": [
+            true,
+            {
+                "call-signature": "nospace",
+                "index-signature": "nospace",
+                "parameter": "nospace",
+                "property-declaration": "nospace",
+                "variable-declaration": "nospace"
+            }
+        ],
+        "variable-name": [
+            true,
+            "ban-keywords"
+        ],
+        "whitespace": [
+            true,
+            "check-branch",
+            "check-decl",
+            "check-operator",
+            "check-separator",
+            "check-type"
+        ]
+    }
+}

typings/bunyan/bunyan.d.ts

@@ -0,0 +1,102 @@
+// Type definitions for node-bunyan
+// Project: https://github.com/trentm/node-bunyan
+// Definitions by: Alex Mikhalev <https://github.com/amikhalev>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "bunyan" {
+    import { EventEmitter } from 'events';
+
+    class Logger extends EventEmitter {
+        constructor(options:LoggerOptions);
+        addStream(stream:Stream):void;
+        addSerializers(serializers:Serializers):void;
+        child(options:LoggerOptions, simple?:boolean):Logger;
+        child(obj:Object, simple?:boolean):Logger;
+        reopenFileStreams():void;
+
+        level():string|number;
+        level(value: number | string):void;
+        levels(name: number | string, value: number | string):void;
+
+        trace(error:Error, format?:any, ...params:any[]):void;
+        trace(buffer:Buffer, format?:any, ...params:any[]):void;
+        trace(obj:Object, format?:any, ...params:any[]):void;
+        trace(format:string, ...params:any[]):void;
+        debug(error:Error, format?:any, ...params:any[]):void;
+        debug(buffer:Buffer, format?:any, ...params:any[]):void;
+        debug(obj:Object, format?:any, ...params:any[]):void;
+        debug(format:string, ...params:any[]):void;
+        info(error:Error, format?:any, ...params:any[]):void;
+        info(buffer:Buffer, format?:any, ...params:any[]):void;
+        info(obj:Object, format?:any, ...params:any[]):void;
+        info(format:string, ...params:any[]):void;
+        warn(error:Error, format?:any, ...params:any[]):void;
+        warn(buffer:Buffer, format?:any, ...params:any[]):void;
+        warn(obj:Object, format?:any, ...params:any[]):void;
+        warn(format:string, ...params:any[]):void;
+        error(error:Error, format?:any, ...params:any[]):void;
+        error(buffer:Buffer, format?:any, ...params:any[]):void;
+        error(obj:Object, format?:any, ...params:any[]):void;
+        error(format:string, ...params:any[]):void;
+        fatal(error:Error, format?:any, ...params:any[]):void;
+        fatal(buffer:Buffer, format?:any, ...params:any[]):void;
+        fatal(obj:Object, format?:any, ...params:any[]):void;
+        fatal(format:string, ...params:any[]):void;
+    }
+
+    interface LoggerOptions {
+        name: string;
+        streams?: Stream[];
+        level?: string | number;
+        stream?: NodeJS.WritableStream;
+        serializers?: Serializers;
+        src?: boolean;
+    }
+
+    interface Serializers {
+        [key:string]: (input:any) => string;
+    }
+
+    interface Stream {
+        type?: string;
+        level?: number | string;
+        path?: string;
+        stream?: NodeJS.WritableStream | Stream;
+        closeOnExit?: boolean;
+        period?: string;
+        count?: number;
+    }
+
+    export var stdSerializers:Serializers;
+
+    export var TRACE:number;
+    export var DEBUG:number;
+    export var INFO:number;
+    export var WARN:number;
+    export var ERROR:number;
+    export var FATAL:number;
+
+    export function resolveLevel(value: number | string):number;
+
+    export function createLogger(options:LoggerOptions):Logger;
+
+    class RingBuffer extends EventEmitter {
+        constructor(options:RingBufferOptions);
+
+        writable:boolean;
+        records:any[];
+
+        write(record:any):void;
+        end(record?:any):void;
+        destroy():void;
+        destroySoon():void;
+    }
+
+    interface RingBufferOptions {
+        limit?: number;
+    }
+
+    export function safeCycles():(key:string, value:any) => any;
+}

typings/form-data/form-data.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for form-data
+// Project: https://github.com/felixge/node-form-data
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Leon Yu <https://github.com/leonyu>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/form-data.d.ts
+
+declare module "form-data" {
+    class FormData {
+        append(key: string, value: any, options?: any): void;
+        getHeaders(): FormData.Dictionary<string>;
+        // TODO expand pipe
+        pipe(to: any): any;
+        submit(params: string | Object, callback: (error: any, response: any) => void): any;
+        getBoundary(): string;
+    }
+
+    namespace FormData {
+        interface Dictionary<T> {
+            [key: string]: T;
+        }
+    }
+
+    export = FormData;
+}

typings/mime/mime.d.ts

@@ -0,0 +1,20 @@
+// Type definitions for mime
+// Project: https://github.com/broofa/node-mime
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/mime.d.ts
+
+declare module "mime" {
+	export function lookup(path: string): string;
+	export function extension(mime: string): string;
+	export function load(filepath: string): void;
+	export function define(mimes: Object): void;
+
+	interface Charsets {
+		lookup(mime: string): string;
+	}
+
+	export var charsets: Charsets;
+	export var default_type: string;
+}

typings/onoff/onoff.d.ts

@@ -0,0 +1,55 @@
+// Type definitions for onoff
+// Project: https://github.com/fivdi/onoff
+// Definitions by: Marcel Ernst <https://github.com/marcel-ernst>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare namespace __ONOFF {
+
+    var version:string;
+
+    interface GpioOptions {
+        debounceTimeout:number;
+    }
+
+    class Gpio {
+        constructor(gpio:number, direction:string);
+        constructor(gpio:number, direction:string, edge:string);
+        constructor(gpio:number, direction:string, edge:string, options:GpioOptions);
+        constructor(gpio:number, direction:string, options:GpioOptions);
+
+        gpio:number
+        gpioPath:string;
+        opts:GpioOptions;
+        readBuffer:Buffer;
+        listeners:Array<(error:Error, value:number) => void>;
+        valueFd:number;
+
+        read(cb:(err:Error, value:number) => void):void;
+        readSync():number;
+
+        write(value:number, cb:(err:Error, value:number) => void):void;
+        writeSync(value:number):void;
+
+        watch(cb:(error:Error, value:number) => void):void;
+        unwatch():void;
+        unwatch(cb:(error:Error, value:number) => void):void;
+        unwatchAll():void;
+
+        direction():string;
+        setDirection(value:string):void;
+
+        edge():string;
+        setEdge(value:string):void;
+
+        options():GpioOptions;
+
+        unexport():void;
+    }
+
+}
+
+declare module "onoff" {
+    export = __ONOFF;
+}

typings/request/request.d.ts

@@ -0,0 +1,262 @@
+// Type definitions for request
+// Project: https://github.com/request/request
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, bonnici <https://github.com/bonnici>, Bart van der Schoor <https://github.com/Bartvds>, Joe Skeen <http://github.com/joeskeen>, Christopher Currens <https://github.com/ccurrens>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/d.ts
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../form-data/form-data.d.ts" />
+
+declare module 'request' {
+	import stream = require('stream');
+	import http = require('http');
+	import https = require('https');
+	import url = require('url');
+	import fs = require('fs');
+	import FormData = require('form-data');
+
+	namespace request {
+		export interface RequestAPI<TRequest extends Request,
+			TOptions extends CoreOptions,
+			TUriUrlOptions> {
+
+			defaults(options: TOptions): RequestAPI<TRequest, TOptions, RequiredUriUrl>;
+			defaults(options: RequiredUriUrl & TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
+
+			(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			(uri: string, callback?: RequestCallback): TRequest;
+			(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			get(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			get(uri: string, callback?: RequestCallback): TRequest;
+			get(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			post(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			post(uri: string, callback?: RequestCallback): TRequest;
+			post(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			put(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			put(uri: string, callback?: RequestCallback): TRequest;
+			put(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			head(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			head(uri: string, callback?: RequestCallback): TRequest;
+			head(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			patch(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			patch(uri: string, callback?: RequestCallback): TRequest;
+			patch(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			del(uri: string, options?: TOptions, callback?: RequestCallback): TRequest;
+			del(uri: string, callback?: RequestCallback): TRequest;
+			del(options: TUriUrlOptions & TOptions, callback?: RequestCallback): TRequest;
+
+			forever(agentOptions: any, optionsArg: any): TRequest;
+			jar(): CookieJar;
+			cookie(str: string): Cookie;
+
+			initParams: any;
+			debug: boolean;
+		}
+
+		interface DefaultUriUrlRequestApi<TRequest extends Request,
+			TOptions extends CoreOptions,
+			TUriUrlOptions>	extends RequestAPI<TRequest, TOptions, TUriUrlOptions> {
+
+			defaults(options: TOptions): DefaultUriUrlRequestApi<TRequest, TOptions, OptionalUriUrl>;
+			(): TRequest;
+			get(): TRequest;
+			post(): TRequest;
+			put(): TRequest;
+			head(): TRequest;
+			patch(): TRequest;
+			del(): TRequest;
+		}
+
+		interface CoreOptions {
+			baseUrl?: string;
+			callback?: (error: any, response: http.IncomingMessage, body: any) => void;
+			jar?: any; // CookieJar
+			formData?: any; // Object
+			form?: any; // Object or string
+			auth?: AuthOptions;
+			oauth?: OAuthOptions;
+			aws?: AWSOptions;
+			hawk?: HawkOptions;
+			qs?: any;
+			json?: any;
+			multipart?: RequestPart[] | Multipart;
+			agent?: http.Agent | https.Agent;
+			agentOptions?: any;
+			agentClass?: any;
+			forever?: any;
+			host?: string;
+			port?: number;
+			method?: string;
+			headers?: Headers;
+			body?: any;
+			followRedirect?: boolean | ((response: http.IncomingMessage) => boolean);
+			followAllRedirects?: boolean;
+			maxRedirects?: number;
+			encoding?: string;
+			pool?: any;
+			timeout?: number;
+			proxy?: any;
+			strictSSL?: boolean;
+			gzip?: boolean;
+			preambleCRLF?: boolean;
+			postambleCRLF?: boolean;
+			key?: Buffer;
+			cert?: Buffer;
+			passphrase?: string;
+			ca?: string | Buffer | string[] | Buffer[];
+			har?: HttpArchiveRequest;
+			useQuerystring?: boolean;
+		}
+
+		interface UriOptions {
+			uri: string;
+		}
+		interface UrlOptions {
+			url: string;
+		}
+		export type RequiredUriUrl = UriOptions | UrlOptions;
+
+		interface OptionalUriUrl {
+			uri?: string;
+			url?: string;
+		}
+
+        export type OptionsWithUri = UriOptions & CoreOptions;
+        export type OptionsWithUrl = UrlOptions & CoreOptions;
+        export type Options = OptionsWithUri | OptionsWithUrl;
+
+		export interface RequestCallback {
+			(error: any, response: http.IncomingMessage, body: any): void;
+		}
+
+		export interface HttpArchiveRequest {
+			url?: string;
+			method?: string;
+			headers?: NameValuePair[];
+			postData?: {
+				mimeType?: string;
+				params?: NameValuePair[];
+			}
+		}
+
+		export interface NameValuePair {
+			name: string;
+			value: string;
+		}
+
+		export interface Multipart {
+			chunked?: boolean;
+			data?: {
+				'content-type'?: string,
+				body: string
+			}[];
+		}
+
+		export interface RequestPart {
+			headers?: Headers;
+			body: any;
+		}
+
+		export interface Request extends stream.Stream {
+			readable: boolean;
+			writable: boolean;
+
+			getAgent(): http.Agent;
+			//start(): void;
+			//abort(): void;
+			pipeDest(dest: any): void;
+			setHeader(name: string, value: string, clobber?: boolean): Request;
+			setHeaders(headers: Headers): Request;
+			qs(q: Object, clobber?: boolean): Request;
+			form(): FormData;
+			form(form: any): Request;
+			multipart(multipart: RequestPart[]): Request;
+			json(val: any): Request;
+			aws(opts: AWSOptions, now?: boolean): Request;
+			auth(username: string, password: string, sendInmediately?: boolean, bearer?: string): Request;
+			oauth(oauth: OAuthOptions): Request;
+			jar(jar: CookieJar): Request;
+
+			on(event: string, listener: Function): this;
+			on(event: 'request', listener: (req: http.ClientRequest) => void): this;
+			on(event: 'response', listener: (resp: http.IncomingMessage) => void): this;
+			on(event: 'data', listener: (data: Buffer | string) => void): this;
+			on(event: 'error', listener: (e: Error) => void): this;
+			on(event: 'complete', listener: (resp: http.IncomingMessage, body?: string | Buffer) => void): this;
+
+			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;
+			end(): void;
+			end(chunk: Buffer, cb?: Function): void;
+			end(chunk: string, cb?: Function): void;
+			end(chunk: string, encoding: string, cb?: Function): void;
+			pause(): void;
+			resume(): void;
+			abort(): void;
+			destroy(): void;
+			toJSON(): Object;
+		}
+
+		export interface Headers {
+			[key: string]: any;
+		}
+
+		export interface AuthOptions {
+			user?: string;
+			username?: string;
+			pass?: string;
+			password?: string;
+			sendImmediately?: boolean;
+			bearer?: string;
+		}
+
+		export interface OAuthOptions {
+			callback?: string;
+			consumer_key?: string;
+			consumer_secret?: string;
+			token?: string;
+			token_secret?: string;
+			verifier?: string;
+		}
+
+		export interface HawkOptions {
+			credentials: any;
+		}
+
+		export interface AWSOptions {
+			secret: string;
+			bucket?: string;
+		}
+
+		export interface CookieJar {
+			setCookie(cookie: Cookie, uri: string | url.Url, options?: any): void
+			getCookieString(uri: string | url.Url): string
+			getCookies(uri: string | url.Url): Cookie[]
+		}
+
+		export interface CookieValue {
+			name: string;
+			value: any;
+			httpOnly: boolean;
+		}
+
+		export interface Cookie extends Array<CookieValue> {
+			constructor(name: string, req: Request): void;
+			str: string;
+			expires: Date;
+			path: string;
+			toString(): string;
+		}
+	}
+	var request: request.RequestAPI<request.Request, request.CoreOptions, request.RequiredUriUrl>;
+	export = request;
+}

typings/serve-static/serve-static.d.ts

@@ -0,0 +1,86 @@
+// Type definitions for serve-static 1.7.1
+// Project: https://github.com/expressjs/serve-static
+// Definitions by: Uros Smolnik <https://github.com/urossmolnik/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/* =================== USAGE ===================
+
+    import * as serveStatic from "serve-static";
+    app.use(serveStatic("public/ftp", {"index": ["default.html", "default.htm"]}))
+
+ =============================================== */
+
+/// <reference path="../express/express.d.ts" />
+/// <reference path="../mime/mime.d.ts" />
+
+declare module "serve-static" {
+    import * as express from "express";
+
+    /**
+     * Create a new middleware function to serve files from within a given root directory.
+     * The file to serve will be determined by combining req.url with the provided root directory.
+     * When a file is not found, instead of sending a 404 response, this module will instead call next() to move on to the next middleware, allowing for stacking and fall-backs.
+     */
+    function serveStatic(root: string, options?: {
+        /**
+         * Set how "dotfiles" are treated when encountered. A dotfile is a file or directory that begins with a dot (".").
+         * Note this check is done on the path itself without checking if the path actually exists on the disk.
+         * If root is specified, only the dotfiles above the root are checked (i.e. the root itself can be within a dotfile when when set to "deny").
+         * The default value is 'ignore'.
+         * 'allow' No special treatment for dotfiles
+         * 'deny' Send a 403 for any request for a dotfile
+         * 'ignore' Pretend like the dotfile does not exist and call next()
+         */
+        dotfiles?: string;
+
+        /**
+         * Enable or disable etag generation, defaults to true.
+         */
+        etag?: boolean;
+
+        /**
+         * Set file extension fallbacks. When set, if a file is not found, the given extensions will be added to the file name and search for.
+         * The first that exists will be served. Example: ['html', 'htm'].
+         * The default value is false.
+         */
+        extensions?: string[];
+
+        /**
+         * By default this module will send "index.html" files in response to a request on a directory.
+         * To disable this set false or to supply a new index pass a string or an array in preferred order.
+         */
+        index?: boolean|string|string[];
+
+        /**
+         * Enable or disable Last-Modified header, defaults to true. Uses the file system's last modified value.
+         */
+        lastModified?: boolean;
+
+        /**
+         * Provide a max-age in milliseconds for http caching, defaults to 0. This can also be a string accepted by the ms module.
+         */
+        maxAge?: number|string;
+
+        /**
+         * Redirect to trailing "/" when the pathname is a dir. Defaults to true.
+         */
+        redirect?: boolean;
+
+        /**
+         * Function to set custom headers on response. Alterations to the headers need to occur synchronously.
+         * The function is called as fn(res, path, stat), where the arguments are:
+         * res the response object
+         * path the file path that is being sent
+         * stat the stat object of the file that is being sent
+         */
+        setHeaders?: (res: express.Response, path: string, stat: any) => any;
+    }): express.Handler;
+
+    import * as m from "mime";
+
+    module serveStatic {
+        var mime: typeof m;
+    }
+
+    export = serveStatic;
+}

typings/socket.io/socket.io.d.ts

@@ -0,0 +1,857 @@
+// Type definitions for socket.io 1.4.4
+// Project: http://socket.io/
+// Definitions by: PROGRE <https://github.com/progre/>, Damian Connolly <https://github.com/divillysausages/>, Florent Poujol <https://github.com/florentpoujol/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path='../node/node.d.ts' />
+
+declare module 'socket.io' {
+	var server: SocketIOStatic;
+
+	export = server;
+}
+
+interface SocketIOStatic {
+	/**
+	 * Default Server constructor
+	 */
+	(): SocketIO.Server;
+	
+	/**
+	 * Creates a new Server
+	 * @param srv The HTTP server that we're going to bind to
+	 * @param opts An optional parameters object
+	 */
+	(srv: any, opts?: SocketIO.ServerOptions): SocketIO.Server;
+	
+	/**
+	 * Creates a new Server
+	 * @param port A port to bind to, as a number, or a string
+	 * @param An optional parameters object
+	 */
+	(port: string|number, opts?: SocketIO.ServerOptions): SocketIO.Server;
+	
+	/**
+	 * Creates a new Server
+	 * @param A parameters object
+	 */
+	(opts: SocketIO.ServerOptions): SocketIO.Server;
+
+	/**
+	 * Backwards compatibility
+	 * @see io().listen()
+	 */
+    listen: SocketIOStatic;
+}
+
+declare module SocketIO {
+	
+	interface Server {
+		
+		/**
+		 * A dictionary of all the namespaces currently on this Server
+		 */
+		nsps: {[namespace: string]: Namespace};
+		
+		/**
+		 * The default '/' Namespace
+		 */
+		sockets: Namespace;
+		
+		/**
+		 * Sets the 'json' flag when emitting an event
+		 */
+		json: Server;
+		
+		/**
+		 * Server request verification function, that checks for allowed origins
+		 * @param req The http.IncomingMessage request
+		 * @param fn The callback to be called. It should take one parameter, err,
+		 * which will be null if there was no problem, and one parameter, success,
+		 * of type boolean
+		 */
+		checkRequest( req:any, fn:( err: any, success: boolean ) => void ):void;
+		
+		/**
+		 * Gets whether we're serving the client.js file or not
+		 * @default true
+		 */
+		serveClient(): boolean;
+		
+		/**
+		 * Sets whether we're serving the client.js file or not
+		 * @param v True if we want to serve the file, false otherwise
+		 * @default true
+		 * @return This Server
+		 */
+		serveClient( v: boolean ): Server;
+		
+		/**
+		 * Gets the client serving path
+		 * @default '/socket.io'
+		 */
+		path(): string;
+		
+		/**
+		 * Sets the client serving path
+		 * @param v The path to serve the client file on
+		 * @default '/socket.io'
+		 * @return This Server
+		 */
+		path( v: string ): Server;
+		
+		/**
+		 * Gets the adapter that we're going to use for handling rooms
+		 * @default typeof Adapter
+		 */
+		adapter(): any;
+		
+		/**
+		 * Sets the adapter (class) that we're going to use for handling rooms
+		 * @param v The class for the adapter to create
+		 * @default typeof Adapter
+		 * @return This Server
+		 */
+		adapter( v: any ): Server;
+		
+		/**
+		 * Gets the allowed origins for requests
+		 * @default "*:*"
+		 */
+		origins(): string;
+		
+		/**
+		 * Sets the allowed origins for requests
+		 * @param v The allowed origins, in host:port form
+		 * @default "*:*"
+		 * return This Server
+		 */
+		origins( v: string ): Server;
+		
+		/**
+		 * Attaches socket.io to a server
+		 * @param srv The http.Server that we want to attach to
+		 * @param opts An optional parameters object
+		 * @return This Server
+		 */
+		attach( srv: any, opts?: ServerOptions ): Server;
+		
+		/**
+		 * Attaches socket.io to a port
+		 * @param port The port that we want to attach to
+		 * @param opts An optional parameters object
+		 * @return This Server
+		 */
+		attach( port: number, opts?: ServerOptions ): Server;
+		
+		/**
+		 * @see attach( srv, opts )
+		 */
+		listen( srv: any, opts?: ServerOptions ): Server;
+		
+		/**
+		 * @see attach( port, opts )
+		 */
+		listen( port: number, opts?: ServerOptions ): Server;
+		
+		/**
+		 * Binds socket.io to an engine.io intsance
+		 * @param src The Engine.io (or compatible) server to bind to
+		 * @return This Server
+		 */
+		bind( srv: any ): Server;
+		
+		/**
+		 * Called with each incoming connection
+		 * @param socket The Engine.io Socket
+		 * @return This Server
+		 */
+		onconnection( socket: any ): Server;
+		
+		/**
+		 * Looks up/creates a Namespace
+		 * @param nsp The name of the NameSpace to look up/create. Should start
+		 * with a '/'
+		 * @return The Namespace
+		 */
+		of( nsp: string ): Namespace;
+		
+		/**
+		 * Closes the server connection
+		 */
+		close():void;
+
+		/**
+		 * The event fired when we get a new connection
+		 * @param event The event being fired: 'connection'
+		 * @param listener A listener that should take one parameter of type Socket
+		 * @return The default '/' Namespace
+		 */
+		on( event: 'connection', listener: ( socket: Socket ) => void ): Namespace;
+		
+		/**
+		 * @see on( 'connection', listener )
+		 */
+		on( event: 'connect', listener: ( socket: Socket ) => void ): Namespace;
+		
+		/**
+		 * Base 'on' method to add a listener for an event
+		 * @param event The event that we want to add a listener for
+		 * @param listener The callback to call when we get the event. The parameters
+		 * for the callback depend on the event
+		 * @return The default '/' Namespace
+		 */
+		on( event: string, listener: Function ): Namespace;
+		
+		/**
+		 * Targets a room when emitting to the default '/' Namespace
+		 * @param room The name of the room that we're targeting 
+		 * @return The default '/' Namespace
+		 */
+		to( room: string ): Namespace;
+		
+		/**
+		 * @see to( room )
+		 */
+		in( room: string ): Namespace;
+		
+		/**
+		 * Registers a middleware function, which is a function that gets executed
+		 * for every incoming Socket, on the default '/' Namespace
+		 * @param fn The function to call when we get a new incoming socket. It should
+		 * take one parameter of type Socket, and one callback function to call to
+		 * execute the next middleware function. The callback can take one optional
+		 * parameter, err, if there was an error. Errors passed to middleware callbacks
+		 * are sent as special 'error' packets to clients
+		 * @return The default '/' Namespace
+		 */
+		use( fn: ( socket:Socket, fn: ( err?: any ) => void ) =>void ): Namespace;
+		
+		/**
+		 * Emits an event to the default Namespace
+		 * @param event The event that we want to emit
+		 * @param args Any number of optional arguments to pass with the event. If the
+		 * last argument is a function, it will be called as an ack. The ack should
+		 * take whatever data was sent with the packet
+		 * @return The default '/' Namespace
+		 */
+		emit( event: string, ...args: any[]): Namespace;
+		
+		/**
+		 * Sends a 'message' event
+		 * @see emit( event, ...args )
+		 * @return The default '/' Namespace
+		 */
+		send( ...args: any[] ): Namespace;
+		
+		/**
+		 * @see send( ...args )
+		 */
+		write( ...args: any[] ): Namespace;
+
+		/**
+		 * Gets a list of clients
+		 * @return The default '/' Namespace
+		 */
+		clients( ...args: any[] ): Namespace;
+
+		/**
+		 * Sets the compress flag
+		 * @return The default '/' Namespace
+		 */
+		compress( ...args: any[] ): Namespace;
+	}
+	
+	/**
+	 * Options to pass to our server when creating it
+	 */
+	interface ServerOptions {
+		
+		/**
+		 * The path to server the client file to
+		 * @default '/socket.io'
+		 */
+		path?: string;
+		
+		/**
+		 * Should we serve the client file?
+		 * @default true
+		 */
+		serveClient?: boolean;
+		
+		/**
+		 * The adapter to use for handling rooms. NOTE: this should be a class,
+		 * not an object
+		 * @default typeof Adapter
+		 */
+		adapter?: Adapter;
+		
+		/**
+		 * Accepted origins
+		 * @default '*:*'
+		 */
+		origins?: string;
+		
+		/**
+		 * How many milliseconds without a pong packed to consider the connection closed (engine.io)
+		 * @default 60000
+		 */
+		pingTimeout?: number;
+		
+		/**
+		 * How many milliseconds before sending a new ping packet (keep-alive) (engine.io)
+		 * @default 25000
+		 */
+		pingInterval?: number;
+		
+		/**
+		 * How many bytes or characters a message can be when polling, before closing the session
+		 * (to avoid Dos) (engine.io)
+		 * @default 10E7
+		 */
+		maxHttpBufferSize?: number;
+		
+		/**
+		 * A function that receives a given handshake or upgrade request as its first parameter,
+		 * and can decide whether to continue or not. The second argument is a function that needs
+		 * to be called with the decided information: fn( err, success ), where success is a boolean
+		 * value where false means that the request is rejected, and err is an error code (engine.io)
+		 * @default null
+		 */
+		allowRequest?: (request:any, callback: (err: number, success: boolean) => void) => void;
+		
+		/**
+		 * Transports to allow connections to (engine.io)
+		 * @default ['polling','websocket']
+		 */
+		transports?: string[];
+		
+		/**
+		 * Whether to allow transport upgrades (engine.io)
+		 * @default true
+		 */
+		allowUpgrades?: boolean;
+		
+		/**
+		 * parameters of the WebSocket permessage-deflate extension (see ws module).
+		 * Set to false to disable (engine.io)
+		 * @default true
+		 */
+		perMessageDeflate?: Object|boolean;
+		
+		/**
+		 * Parameters of the http compression for the polling transports (see zlib).
+		 * Set to false to disable, or set an object with parameter "threshold:number"
+		 * to only compress data if the byte size is above this value (1024) (engine.io)
+		 * @default true|1024
+		 */
+		httpCompression?: Object|boolean;
+		
+		/**
+		 * Name of the HTTP cookie that contains the client sid to send as part of 
+		 * handshake response headers. Set to false to not send one (engine.io)
+		 * @default "io"
+		 */
+		cookie?: string|boolean;
+	}
+
+	/**
+	 * The Namespace, sandboxed environments for sockets, each connection
+	 * to a Namespace requires a new Socket
+	 */
+	interface Namespace extends NodeJS.EventEmitter {
+		
+		/**
+		 * The name of the NameSpace
+		 */
+		name: string;
+		
+		/**
+		 * The controller Server for this Namespace
+		 */
+		server: Server;
+		
+		/**
+		 * A dictionary of all the Sockets connected to this Namespace, where
+		 * the Socket ID is the key
+		 */
+		sockets: { [id: string]: Socket };
+		
+		/**
+		 * A dictionary of all the Sockets connected to this Namespace, where
+		 * the Socket ID is the key
+		 */
+		connected: { [id: string]: Socket };
+		
+		/**
+		 * The Adapter that we're using to handle dealing with rooms etc
+		 */
+		adapter: Adapter;
+		
+		/**
+		 * Sets the 'json' flag when emitting an event
+		 */
+		json: Namespace;
+		
+		/**
+		 * Registers a middleware function, which is a function that gets executed
+		 * for every incoming Socket
+		 * @param fn The function to call when we get a new incoming socket. It should
+		 * take one parameter of type Socket, and one callback function to call to
+		 * execute the next middleware function. The callback can take one optional
+		 * parameter, err, if there was an error. Errors passed to middleware callbacks
+		 * are sent as special 'error' packets to clients
+		 * @return This Namespace
+		 */
+		use( fn: ( socket:Socket, fn: ( err?: any ) => void ) =>void ): Namespace;
+		
+		/**
+		 * Targets a room when emitting
+		 * @param room The name of the room that we're targeting 
+		 * @return This Namespace
+		 */
+		to( room: string ): Namespace;
+		
+		/**
+		 * @see to( room )
+		 */
+		in( room: string ): Namespace;
+		
+		/**
+		 * Sends a 'message' event
+		 * @see emit( event, ...args )
+		 * @return This Namespace
+		 */
+		send( ...args: any[] ): Namespace;
+		
+		/**
+		 * @see send( ...args )
+		 */
+		write( ...args: any[] ): Namespace;
+
+		/**
+		 * The event fired when we get a new connection
+		 * @param event The event being fired: 'connection'
+		 * @param listener A listener that should take one parameter of type Socket
+		 * @return This Namespace
+		 */
+		on( event: 'connection', listener: ( socket: Socket ) => void ): any;
+		
+		/**
+		 * @see on( 'connection', listener )
+		 */
+		on( event: 'connect', listener: ( socket: Socket ) => void ): any;
+		
+		/**
+		 * Base 'on' method to add a listener for an event
+		 * @param event The event that we want to add a listener for
+		 * @param listener The callback to call when we get the event. The parameters
+		 * for the callback depend on the event
+		 * @ This Namespace
+		 */
+		on( event: string, listener: Function ): any;
+
+		/**
+		 * Gets a list of clients.
+		 * @return This Namespace
+		 */
+		clients( fn: Function ): Namespace;
+
+		/**
+		 * Sets the compress flag.
+		 * @param compress If `true`, compresses the sending data
+		 * @return This Namespace
+		 */
+		compress( compress: boolean ): Namespace;
+	}
+
+	/**
+	 * The socket, which handles our connection for a namespace. NOTE: while
+	 * we technically extend NodeJS.EventEmitter, we're not putting it here
+	 * as we have a problem with the emit() event (as it's overridden with a
+	 * different return)
+	 */
+	interface Socket {
+		
+		/**
+		 * The namespace that this socket is for
+		 */
+		nsp: Namespace;
+		
+		/**
+		 * The Server that our namespace is in
+		 */
+		server: Server;
+		
+		/**
+		 * The Adapter that we use to handle our rooms
+		 */
+		adapter: Adapter;
+		
+		/**
+		 * The unique ID for this Socket. Regenerated at every connection. This is
+		 * also the name of the room that the Socket automatically joins on connection
+		 */
+		id: string;
+		
+		/**
+		 * The http.IncomingMessage request sent with the connection. Useful 
+		 * for recovering headers etc
+		 */
+		request: any;
+		
+		/**
+		 * The Client associated with this Socket
+		 */
+		client: Client;
+		
+		/**
+		 * The underlying Engine.io Socket instance
+		 */
+		conn: {
+		
+			/**
+			 * The ID for this socket - matches Client.id
+			 */
+			id: string;
+			
+			/**
+			 * The Engine.io Server for this socket
+			 */
+			server: any;
+			
+			/**
+			 * The ready state for the client. Either 'opening', 'open', 'closing', or 'closed'
+			 */
+			readyState: string;
+			
+			/**
+			 * The remote IP for this connection
+			 */
+			remoteAddress: string;
+		};
+		
+		/**
+		 * The list of rooms that this Socket is currently in, where
+		 * the ID the the room ID
+		 */
+		rooms: { [id: string]: string };
+		
+		/**
+		 * Is the Socket currently connected?
+		 */
+		connected: boolean;
+		
+		/**
+		 * Is the Socket currently disconnected?
+		 */
+		disconnected: boolean;
+		
+		/**
+		 * The object used when negociating the handshake
+		 */
+		handshake: {
+			/**
+			 * The headers passed along with the request. e.g. 'host', 
+			 * 'connection', 'accept', 'referer', 'cookie'
+			 */
+			headers: any;
+			
+			/**
+			 * The current time, as a string
+			 */
+			time: string;
+			
+			/**
+			 * The remote address of the connection request
+			 */
+			address: string;
+			
+			/**
+			 * Is this a cross-domain request?
+			 */
+			xdomain: boolean;
+			
+			/**
+			 * Is this a secure request?
+			 */
+			secure: boolean;
+			
+			/**
+			 * The timestamp for when this was issued
+			 */
+			issued: number;
+			
+			/**
+			 * The request url
+			 */
+			url: string;
+			
+			/**
+			 * Any query string parameters in the request url
+			 */
+			query: any;
+		};
+		
+		/**
+		 * Sets the 'json' flag when emitting an event
+		 */
+		json: Socket;
+		
+		/**
+		 * Sets the 'volatile' flag when emitting an event. Volatile messages are
+		 * messages that can be dropped because of network issues and the like. Use
+		 * for high-volume/real-time messages where you don't need to receive *all*
+		 * of them
+		 */
+		volatile: Socket;
+		
+		/**
+		 * Sets the 'broadcast' flag when emitting an event. Broadcasting an event
+		 * will send it to all the other sockets in the namespace except for yourself
+		 */
+		broadcast: Socket;
+		
+		/**
+		 * Emits an event to this client. If the 'broadcast' flag was set, this will
+		 * emit to all other clients, except for this one
+		 * @param event The event that we want to emit
+		 * @param args Any number of optional arguments to pass with the event. If the
+		 * last argument is a function, it will be called as an ack. The ack should
+		 * take whatever data was sent with the packet
+		 * @return This Socket
+		 */
+		emit( event: string, ...args: any[]): Socket;
+		
+		/**
+		 * Targets a room when broadcasting
+		 * @param room The name of the room that we're targeting
+		 * @return This Socket
+		 */
+		to( room: string ): Socket;
+		
+		/**
+		 * @see to( room )
+		 */
+		in( room: string ): Socket;
+		
+		/**
+		 * Sends a 'message' event
+		 * @see emit( event, ...args )
+		 */
+		send( ...args: any[] ): Socket;
+		
+		/**
+		 * @see send( ...args )
+		 */
+		write( ...args: any[] ): Socket;
+		
+		/**
+		 * Joins a room. You can join multiple rooms, and by default, on connection,
+		 * you join a room with the same name as your ID
+		 * @param name The name of the room that we want to join
+		 * @param fn An optional callback to call when we've joined the room. It should
+		 * take an optional parameter, err, of a possible error
+		 * @return This Socket
+		 */
+		join( name: string, fn?: ( err?: any ) => void ): Socket;
+		
+		/**
+		 * Leaves a room
+		 * @param name The name of the room to leave
+		 * @param fn An optional callback to call when we've left the room. It should
+		 * take on optional parameter, err, of a possible error
+		 */
+		leave( name: string, fn?: Function ): Socket;
+		
+		/**
+		 * Leaves all the rooms that we've joined
+		 */
+		leaveAll(): void;
+		
+		/**
+		 * Disconnects this Socket
+		 * @param close If true, also closes the underlying connection
+		 * @return This Socket
+		 */
+		disconnect( close?: boolean ): Socket;
+		
+		/**
+		 * Adds a listener for a particular event. Calling multiple times will add
+		 * multiple listeners
+		 * @param event The event that we're listening for
+		 * @param fn The function to call when we get the event. Parameters depend on the 
+		 * event in question
+		 * @return This Socket
+		 */
+		on( event: string, fn: Function ): Socket;
+		
+		/**
+		 * @see on( event, fn )
+		 */
+		addListener( event: string, fn: Function ): Socket;
+		
+		/**
+		 * Adds a listener for a particular event that will be invoked
+		 * a single time before being automatically removed
+		 * @param event The event that we're listening for
+		 * @param fn The function to call when we get the event. Parameters depend on
+		 * the event in question
+		 * @return This Socket
+		 */
+		once( event: string, fn: Function ): Socket;
+		
+		/**
+		 * Removes a listener for a particular type of event. This will either
+		 * remove a specific listener, or all listeners for this type of event
+		 * @param event The event that we want to remove the listener of
+		 * @param fn The function to remove, or null if we want to remove all functions
+		 * @return This Socket
+		 */
+		removeListener( event: string, fn?: Function ): Socket;
+		
+		/**
+		 * Removes all event listeners on this object
+		 * @return This Socket
+		 */
+		removeAllListeners( event?: string ): Socket;
+		
+		/**
+		 * Sets the maximum number of listeners this instance can have
+		 * @param n The max number of listeners we can add to this emitter
+		 * @return This Socket
+		 */
+		setMaxListeners( n: number ): Socket;
+		
+		/**
+		 * Returns all the callbacks for a particular event
+		 * @param event The event that we're looking for the callbacks of
+		 * @return An array of callback Functions, or an empty array if we don't have any
+		 */
+		listeners( event: string ):Function[];
+
+		/**
+		 * Sets the compress flag
+		 * @param compress If `true`, compresses the sending data
+		 * @return This Socket
+		 */
+		compress( compress: boolean ): Socket;
+	}
+	
+	/**
+	 * The interface used when dealing with rooms etc
+	 */
+	interface Adapter extends NodeJS.EventEmitter {
+		
+		/**
+		 * The namespace that this adapter is for
+		 */
+		nsp: Namespace;
+		
+		/**
+		 * A dictionary of all the rooms that we have in this namespace
+		 * The rooms are made of a `sockets` key which is the dictionary of sockets per ID
+		 */
+		rooms: {[room: string]: {sockets: {[id: string]: boolean }}};
+		
+		/**
+		 * A dictionary of all the socket ids that we're dealing with, and all
+		 * the rooms that the socket is currently in
+		 */
+		sids: {[id: string]: {[room: string]: boolean}};
+		
+		/**
+		 * Adds a socket to a room. If the room doesn't exist, it's created
+		 * @param id The ID of the socket to add
+		 * @param room The name of the room to add the socket to
+		 * @param callback An optional callback to call when the socket has been 
+		 * added. It should take an optional parameter, error, if there was a problem
+		 */
+		add( id: string, room: string, callback?: ( err?: any ) => void ): void;
+		
+		/**
+		 * Removes a socket from a room. If there are no more sockets in the room,
+		 * the room is deleted
+		 * @param id The ID of the socket that we're removing
+		 * @param room The name of the room to remove the socket from
+		 * @param callback An optional callback to call when the socket has been
+		 * removed. It should take on optional parameter, error, if there was a problem
+		 */
+		del( id: string, room: string, callback?: ( err?: any ) => void ): void;
+		
+		/**
+		 * Removes a socket from all the rooms that it's joined
+		 * @param id The ID of the socket that we're removing
+		 */
+		delAll( id: string ):void;
+		
+		/**
+		 * Broadcasts a packet
+		 * @param packet The packet to broadcast
+		 * @param opts Any options to send along:
+		 * 	- rooms: An optional list of rooms to broadcast to. If empty, the packet is broadcast to all sockets
+		 * 	- except: A list of Socket IDs to exclude
+		 * 	- flags: Any flags that we want to send along ('json', 'volatile', 'broadcast')
+		 */
+		broadcast( packet: any, opts: { rooms?: string[]; except?: string[]; flags?: {[flag: string]: boolean} } ):void;
+	}
+
+	/**
+	 * The client behind each socket (can have multiple sockets)
+	 */
+	interface Client {
+		/**
+		 * The Server that this client belongs to
+		 */
+		server: Server;
+		
+		/**
+		 * The underlying Engine.io Socket instance
+		 */
+		conn: {
+		
+			/**
+			 * The ID for this socket - matches Client.id
+			 */
+			id: string;
+			
+			/**
+			 * The Engine.io Server for this socket
+			 */
+			server: any;
+			
+			/**
+			 * The ready state for the client. Either 'opening', 'open', 'closing', or 'closed'
+			 */
+			readyState: string;
+			
+			/**
+			 * The remote IP for this connection
+			 */
+			remoteAddress: string;
+		};
+		
+		/**
+		 * The ID for this client. Regenerated at every connection
+		 */
+		id: string;
+		
+		/**
+		 * The http.IncomingMessage request sent with the connection. Useful 
+		 * for recovering headers etc
+		 */
+		request: any;
+		
+		/**
+		 * The dictionary of sockets currently connect via this client (i.e. to different
+		 * namespaces) where the Socket ID is the key
+		 */
+		sockets: {[id: string]: Socket};
+		
+		/**
+		 * A dictionary of all the namespaces for this client, with the Socket that
+		 * deals with that namespace
+		 */
+		nsps: {[nsp: string]: Socket};
+	}
+}

typings/tsd.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="bunyan/bunyan.d.ts" />
+/// <reference path="express/express.d.ts" />
+/// <reference path="mime/mime.d.ts" />
+/// <reference path="node/node.d.ts" />
+/// <reference path="serve-static/serve-static.d.ts" />
+/// <reference path="socket.io/socket.io.d.ts" />
+/// <reference path="underscore/underscore.d.ts" />
+/// <reference path="onoff/onoff.d.ts" />
+/// <reference path="form-data/form-data.d.ts" />
+/// <reference path="request/request.d.ts" />