diff --git a/irc/irc-tests.ts b/irc/irc-tests.ts
new file mode 100644
index 0000000000..edda5e14fd
--- /dev/null
+++ b/irc/irc-tests.ts
@@ -0,0 +1,54 @@
+/// <reference path="irc.d.ts" />
+// https://github.com/martynsmith/node-irc/blob/master/example/bot.js
+
+import irc = require('irc');
+
+var bot = new irc.Client('irc.dollyfish.net.nz', 'nodebot', {
+    debug: true,
+    channels: ['#blah', '#test']
+});
+
+bot.addListener('error', <irc.handlers.IError> ((message: irc.IMessage) => {
+    console.error('ERROR: %s: %s', message.command, message.args.join(' '));
+}));
+
+bot.addListener('message#blah', <irc.handlers.IMessageChannel> ((from: string, message: string) => {
+    console.log('<%s> %s', from, message);
+}));
+
+bot.addListener('message', <irc.handlers.IRecievedMessage> ((from: string, to: string, message: string) => {
+    console.log('%s => %s: %s', from, to, message);
+
+    if (to.match(/^[#&]/)) {
+        // channel message
+        if (message.match(/hello/i)) {
+            bot.say(to, 'Hello there ' + from);
+        }
+        if (message.match(/dance/)) {
+            setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D\\-<\u0001'); }, 1000);
+            setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D|-<\u0001');  }, 2000);
+            setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D/-<\u0001');  }, 3000);
+            setTimeout(() => { bot.say(to, '\u0001ACTION dances: :D|-<\u0001');  }, 4000);
+        }
+    }
+    else {
+        // private message
+        console.log('private message');
+    }
+}));
+
+bot.addListener('pm', <irc.handlers.IPm> ((nick: string, message: string) => {
+    console.log('Got private message from %s: %s', nick, message);
+}));
+
+bot.addListener('join', <irc.handlers.IJoin> ((channel: string, who: string) => {
+    console.log('%s has joined %s', who, channel);
+}));
+
+bot.addListener('part', <irc.handlers.IPart> ((channel: string, who: string, reason: string) => {
+    console.log('%s has left %s: %s', who, channel, reason);
+}));
+
+bot.addListener('kick', <irc.handlers.IKick> ((channel: string, who: string, by: string, reason: string) => {
+    console.log('%s was kicked from %s by %s: %s', who, channel, by, reason);
+}));
diff --git a/irc/irc.d.ts b/irc/irc.d.ts
new file mode 100644
index 0000000000..11f14ab6f2
--- /dev/null
+++ b/irc/irc.d.ts
@@ -0,0 +1,879 @@
+// Type definitions for irc v0.3.12
+// Project: https://github.com/martynsmith/node-irc
+// Definitions by: phillips1012 <https://github.com/phillips1012>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node-0.10.d.ts" />
+
+/** This library provides IRC client functionality. */
+declare module 'irc' {
+    import events = require('events');
+    import crypto = require('crypto');
+    import net = require('net');
+
+    /** This library provides IRC client functionality. */
+    module NodeIRC {
+        /** A nick connect to an IRC server. */
+        export class Client extends events.EventEmitter {
+            /**
+             * Socket to the server. Rarely, if ever needed. Use Client#send
+             * instead.
+             */
+            public conn: net.Socket
+
+            /**
+             * Channels joined. Includes channel modes, user list, and topic
+             * information. Only updated after the server recognizes the join.
+             */
+            public chans: {
+                [index: string]: {
+                    key: string;
+                    serverName: string;
+                    users: {
+                        [index: string]: string;
+                    };
+                    mode: string;
+                    created: string;
+                }
+            }
+
+            /** Features supported by the server */
+            public supported: {
+                channel: {
+                    idlength: string[];
+                    length: number;
+                    limit: string[];
+                    modes: {
+                        [index: string]: string;
+                    }
+                    types: string;
+                };
+
+                kicklength: number;
+                maxlist: number[];
+                maxtargets: string[];
+                modes: number;
+                nicklength: number
+                topiclength: number;
+                usermodes: string;
+            }
+
+            /**
+             * The current nick of the client. Updated if the nick changes
+             */
+            public nick: string;
+
+            /** Channel listing data. */
+            public channellist: IChannel[];
+
+            /** IRC server MOTD */
+            public motd: string;
+
+            /** Maximum line length */
+            public maxLineLength: number;
+
+            /** Bot options */
+            public opt: IClientOpts;
+
+            /** Host mask */
+            public hostMask: string;
+
+            /**
+             * Connect to an IRC server
+             * @param server - server hostname
+             * @param nick - nickname
+             * @param opts
+             */
+            constructor(
+                server: string,
+                nick: string,
+                opts?: IClientOpts
+            );
+
+            /**
+             * Send a raw message to the server; generally speaking, it’s best
+             * not to use this method unless you know what you’re doing.
+             * @param command - irc command
+             * @param args - command arguments (splat)
+             */
+            public send(
+                command: string,
+                ...args: string[]
+            ): void;
+
+            /**
+             * Join the specified channel
+             * @param channel - channel to join
+             * @param callback
+             */
+            public join(
+                channel: string,
+                callback?: handlers.IJoinChannel
+            ): void;
+
+            /**
+             * Part the specified channel
+             * @param channel - channel to part
+             * @param message - optional message to send
+             * @param callback
+             */
+            public part(
+                channel: string,
+                message: string,
+                callback: handlers.IPartChannel
+            ): void;
+
+            /**
+             * Send a message to the specified target
+             * @param target - nick or channel
+             * @param message - message to send
+             */
+            public say(
+                target: string,
+                message: string
+            ): void;
+
+            /**
+             * Send a CTCP message to the specified target
+             * @param target - nick or channel
+             * @param type - "privmsg" for PRIVMSG, anything else for NOTICE
+             * @param text - CTCP message
+             */
+            public ctcp(
+                target: string,
+                type: string,
+                text: string
+            ): void;
+
+            /**
+             * Send an action to the specified target
+             * @param target - target
+             * @param message - message
+             */
+            public action(
+                target: string,
+                message: string
+            ): void;
+
+            /**
+             * Send a notice to the specified target.
+             * @param target - nick or channel
+             * @param message - message to send
+             */
+            public notice(
+                target: string,
+                message: string
+            ): void;
+
+            /**
+             * Request a whois for the specified nick
+             * @param nick - nickname
+             * @param callback
+             */
+            public whois(
+                nick: string,
+                callback: handlers.IWhois
+            ): void;
+
+            /**
+             * Request a channel listing from the server. The arguments for this
+             * are farily server specific, this method passes them as specified.
+             *
+             * Responses from the server are available via `channellist_start`,
+             * `channellist_item`, and `channellist` events.
+             *
+             * @param args - arguments
+             */
+            public list(
+                ...args:  string[]
+            ): void;
+
+            /**
+             * Connect to the server. Use when `autoConnect` is false.
+             * @param retryCount - times to retry
+             * @param callback
+             */
+            public connect(
+                retryCount?: number,
+                callback?: handlers.IRaw
+            ): void;
+
+            /**
+             * Disconnect from the IRC server
+             * @param message - message to send
+             * @param callback
+             */
+            public disconnect(
+                message: string,
+                callback: () => void
+            ): void;
+
+            /**
+             * Activate flood protection “after the fact”. You can also use
+             * floodProtection while instantiating the Client to enable flood
+             * protection, and floodProtectionDelay to set the default message
+             * interval.
+             * @param interval - ms to wait between messages
+             */
+            public activateFloodProtection(
+                interval: number
+            ): void;
+        }
+
+        /** Client options object */
+        export interface IClientOpts {
+            /**
+             * IRC username
+             * @default 'nodebot'
+             */
+            userName?: string;
+
+            /**
+             * IRC "real name"
+             * @default 'nodeJS IRC client'
+             */
+            realName?: string;
+
+            /**
+             * IRC connection port. See
+             * https://nodejs.org/api/net.html#net_socket_remoteport
+             * @default 6667
+             */
+            port?: number;
+
+            /**
+             * Local interface to bind to for network connections. See
+             * https://nodejs.org/api/net.html#net_socket_localaddress
+             */
+            localAddress?: string;
+
+            /**
+             * Should we output debug messages to STDOUT?
+             * @default false
+             */
+            debug?: boolean;
+
+            /**
+             * Should we output IRC errors?
+             * @default false
+             */
+            showErrors?: boolean;
+
+            /**
+             * Should we auto-rejoin channels?
+             * @default false
+             */
+            autoRejoin?: boolean;
+
+            /**
+             * Should we auto-reconnect to networks?
+             * @default true
+             */
+            autoConnect?: boolean;
+
+            /**
+             * Channels to join
+             * @default []
+             */
+            channels?: string[];
+
+            /**
+             * Should SSL be used? Can either be true or crypto credentials.
+             * @default false
+             */
+            secure?: boolean | crypto.Credentials;
+
+            /**
+             * Should we accept self-signed certificates?
+             * @default false
+             */
+            selfSigned?: boolean;
+
+
+            /**
+             * Should we accept expired certificates?
+             * @default false
+             */
+            certExpired?: boolean;
+
+            /**
+             * Should we queue our messages to ensure we don't get kicked?
+             * @default false
+             */
+            floodProtection?: boolean;
+
+            /**
+             * Delay between messages when flood protection is active
+             * @default 1000
+             */
+            floodProtectionDelay?: number;
+
+            /**
+             * Should we use SASL authentication?
+             * @default false
+             */
+            sasl?: boolean;
+
+            /**
+             * Should we strip mIRC colors from the output messages?
+             * @default false
+             */
+            stripColors?: boolean;
+
+            /**
+             * Channel prefix
+             * @default '&#'
+             */
+            channelPrefixes?: string;
+
+            /**
+             * Characters to split a message at.
+             * @default 512
+             */
+            messageSplit?: number;
+
+            /**
+             * Encoding to use. See
+             * https://nodejs.org/api/stream.html#stream_readable_setencoding_encoding
+             * @default 'utf-8'
+             */
+            encoding?: string;
+        }
+
+        /** Command types */
+        export enum CommandType {
+            normal, reply, error
+        }
+
+        /** Parsed IRC message. */
+        export interface IMessage {
+            /** Prefix */
+            prefix?: string;
+
+            /** Mapped IRC command */
+            command: string;
+
+            /** Raw IRC command */
+            rawCommand: string;
+
+            /** Command type */
+            commandType: CommandType;
+
+            /** Command arguments */
+            args: string[];
+        }
+
+        /** Whois data */
+        export interface IWhoisData {
+            /** Nickname */
+            nick: string;
+
+            /** Username */
+            user: string;
+
+            /** Hostnamej */
+            host: string;
+
+            /** Real name" */
+            realname: string;
+
+            /** Channels */
+            channels: string[];
+
+            /** Server */
+            server: string;
+
+            /** Server description string */
+            serverinfo: string;
+
+            /** Is this user an operator? */
+            operator: string;
+        }
+
+        /** A channel returned by a channel listing. */
+        export interface IChannel {
+            /** Channel name */
+            name: string;
+
+            /** User count */
+            users: string;
+
+            /** Topic string */
+            topic: string;
+        }
+
+        /**
+         * Handler functions for Client.
+         */
+        module handlers {
+            /**
+             * 'registered': Emitted when the server sends the initial 001 line,
+             * indicating you’ve connected to the server. See the raw event for
+             * details on the message object.
+             */
+            export interface IRegistered {
+                /**
+                 * @param message - raw message
+                 */
+                (message: IMessage): void;
+            }
+
+            /**
+             * 'motd': Emitted when the server sends the message of the day to
+             * clients.
+             */
+            export interface IMotd {
+                /**
+                 * @param motd - motd string
+                 */
+                (motd: string): void;
+            }
+
+            /**
+             * 'names': Emitted when the server sends a list of nicks for a channel
+             * (which happens immediately after joining and on request. The nicks
+             * object passed to the callback is keyed by nick names, and has
+             * values ‘’, ‘+’, or ‘@’ depending on the level of that nick in the
+             * channel.
+             */
+            export interface INames {
+                /**
+                 * @param channel - channel name
+                 * @param nicks - nicks list
+                 */
+                (channel: string, nicks: string[]): void;
+            }
+
+            /**
+             * 'names#*' As per ‘names’ event but only emits for the subscribed
+             * channel.
+             */
+            export interface INamesChannel {
+                /**
+                 * @param channel - channel name
+                 * @param nicks - nicks list
+                 */
+                (nicks: string[]): void;
+            }
+
+            /**
+             * 'topic': Emitted when the server sends the channel topic on joining
+             * a channel, or when a user changes the topic on a channel. See the
+             * raw event for details on the message object.
+             */
+            export interface ITopic {
+                /**
+                 * @param channel - channel name
+                 * @param topic - topic
+                 * @param nick - nick
+                 * @param message - raw message
+                 */
+                (
+                    channel: string,
+                    topic: string,
+                    nick: string,
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'join': Emitted when a user joins a channel (including when the
+             * client itself joins a channel). See the raw event for details on the
+             * message object.
+             */
+            export interface IJoin {
+                /**
+                 * @param channel - channel name
+                 * @param nick - who joined
+                 * @param message - raw message
+                 */
+                (channel: string, nick: string, message: IMessage): void;
+            }
+
+            /**
+             * 'join#*': As per ‘join’ event but only emits for the subscribed
+             * channel. See the raw event for details on the message object.
+             */
+            export interface IJoinChannel {
+                /**
+                 * @param nick - who joined
+                 * @param message - raw message
+                 */
+                (nick: string, message: IMessage): void;
+            }
+
+            /**
+             * 'part': Emitted when a user parts a channel (including when the
+             * client itself parts a channel). See the raw event for details on the
+             * message object.
+             */
+            export interface IPart {
+                /**
+                 * @param channel - channel name
+                 * @param nick - who parted
+                 * @param reason - part reason
+                 * @param message - raw message
+                 */
+                (
+                    channel: string,
+                    nick: string,
+                    reason: string,
+                    message: IMessage
+                ): void
+            }
+
+            /**
+             * 'part': As per ‘part’ event but only emits for the subscribed
+             * channel. See the raw event for details on the message object.
+             */
+            export interface IPartChannel {
+                /**
+                 * @param nick - who parted
+                 * @param reason - part reason
+                 * @param message - raw message
+                 */
+                (
+                    nick: string,
+                    reason: string,
+                    message: IMessage
+                ): void
+            }
+
+            /**
+             * 'kick': Emitted when a user is kicked from a channel. See the raw
+             * event for details on the message object.
+             */
+            export interface IKick {
+                /**
+                 * @param channel - channel name
+                 * @param nick - who was kicked
+                 * @param by - kicker
+                 * @param reason - kick reason
+                 * @param message - raw message
+                 */
+                (
+                    channel: string,
+                    nick: string,
+                    by: string,
+                    reason: string,
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'kick#*': Emitted when a user is kicked from a channel. See the raw
+             * event for details on the message object.
+             */
+            export interface IKickChannel {
+                /**
+                 * @param nick - who was kicked
+                 * @param by - kicker
+                 * @param reason - kick reason
+                 * @param message - raw message
+                 */
+                (
+                    nick: string,
+                    by: string,
+                    reason: string,
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'message': Emitted when a message is sent. to can be either a nick
+             * (which is most likely this clients nick and means a private message),
+             * or a channel (which means a message to that channel). See the raw
+             * event for details on the message object.
+             */
+            export interface IRecievedMessage {
+                /**
+                 * @param nick - who sent the message
+                 * @param to - to whom was the message sent
+                 * @param text - message text
+                 * @param message - raw message
+                 */
+                (
+                    nick: string, to: string, text: string, message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'message#': Emitted when a message is sent to any channel (i.e.
+             * exactly the same as the message event but excluding private
+             * messages. See the raw event for details on the message object.
+             */
+            export interface IMessageAllChannels {
+                /**
+                 * @param nick - who sent the message
+                 * @param to - to whom was the message sent
+                 * @param text - message text
+                 * @param message - raw message
+                 */
+                (
+                    nick: string, to: string, text: string, message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'message#*': As per ‘message’ event but only emits for the
+             * subscribed channel. See the raw event for details on the message
+             * object.
+             */
+            export interface IMessageChannel {
+                /**
+                 * @param nick - who sent the message
+                 * @param text - message text
+                 * @param message - raw message
+                 */
+                (nick: string, text: string, message: IMessage): void;
+            }
+
+            /**
+             * 'selfMessage': Emitted when a message is sent from the client.
+             * `to` is who the message was sent to. It can be either a nick
+             * (which most likely means a private message), or a channel (which
+             * means a message to that channel).
+             */
+            export interface ISelfMessage {
+                (to: string, text: string): void;
+            }
+
+            /**
+             * 'notice': Emitted when a notice is sent. to can be either a nick
+             * (which is most likely this clients nick and means a private
+             * message), or a channel (which means a message to that channel). nick
+             * is either the senders nick or null which means that the notice comes
+             * from the server. See the raw event for details on the message object.
+             */
+            export interface INotice {
+                /**
+                 * @param nick - from
+                 * @param to - to
+                 * @param text - text
+                 * @param message - raw message
+                 */
+                (nick: string, to: string, text: string, message: IMessage): void;
+            }
+
+            /**
+             * 'ping': Emitted when a server PINGs the client. The client will
+             * automatically send a PONG request just before this is emitted.
+             */
+            export interface IPing {
+                /**
+                 * @param server - server that adiministered the ping
+                 */
+                (server: string): void;
+            }
+
+            /**
+             * 'pm': As per ‘message’ event but only emits when the message is
+             * direct to the client. See the raw event for details on the message
+             * object.
+             */
+            export interface IPm {
+                /**
+                 * @param nick - sender
+                 * @param text - message text
+                 * @param message - raw message
+                 */
+                (nick: string, text: string, message: IMessage): void;
+            }
+
+            /**
+             * 'ctcp': Emitted when a CTCP notice or privmsg was received (type
+             * is either ‘notice’ or ‘privmsg’). See the raw event for details
+             * on the message object.
+             */
+            export interface ICtcp {
+                /**
+                 * @param from - sender
+                 * @param to - recievier
+                 * @param text - ctcp text
+                 * @param type - ctcp type
+                 * @param message - raw message
+                 */
+                (
+                    from: string,
+                    to: string,
+                    text: string,
+                    type: string,
+                    message: IMessage
+                ): void;
+            }
+
+
+            /**
+             * 'ctcp-*': Emitted when a specific type of CTCP request was
+             * recieved.
+             */
+            export interface ICtcpSpecific {
+                /**
+                 * @param from - sender
+                 * @param to - recievier
+                 * @param message - raw message
+                 */
+                (
+                    from: string,
+                    to: string,
+                    text: string,
+                    message: IMessage
+                ): void;
+
+                (
+                    from: string,
+                    to: string,
+                    text: string,
+                    type: string,
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'nick': Emitted when a user changes nick along with the channels
+             * the user is in. See the raw event for details on the message
+             * object.
+             */
+            export interface INick {
+                /**
+                 * @param oldnick - old nickname
+                 * @param newnick - new nickname
+                 * @param channels - channels the nick changed in
+                 * @param message - raw message
+                 */
+                (
+                    oldnick: string,
+                    newnick: string,
+                    channels: string[],
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'invite': Emitted when the client receives an /invite. See the
+             * raw event for details on the message object.
+             */
+            export interface IInvite {
+                /**
+                 * @param channel - channel user was invited to
+                 * @param from - user who invited
+                 * @param message - raw message
+                 */
+                (channel: string, from: string, message: IMessage): void;
+            }
+
+            /**
+             * '+mode'/'-mode': Emitted when a mode is added or removed from a user or
+             * channel. channel is the channel which the mode is being set on/in
+             * . by is the user setting the mode. mode is the single character
+             * mode identifier. If the mode is being set on a user, argument is
+             * the nick of the user. If the mode is being set on a channel,
+             * argument is the argument to the mode. If a channel mode doesn’t
+             * have any arguments, argument will be ‘undefined’. See the raw
+             * event for details on the message object.
+             */
+            export interface IModeChange {
+                /**
+                 * @param channel - channel
+                 * @param by - nick that changed mode
+                 * @param mode - single character mode identifier
+                 * @param argument - mode argument
+                 * @param message - raw message
+                 */
+                (
+                    channel: string,
+                    by: string,
+                    mode: string,
+                    argument: string,
+                    message: IMessage
+                ): void;
+            }
+
+            /**
+             * 'whois': Emitted whenever the server finishes outputting a WHOIS
+             * response.
+             */
+            export interface IWhois {
+                (info: IWhoisData): void;
+            }
+
+            /**
+             * 'channellist': Emitted when the server has finished returning a
+             * channel list. The channel_list array is simply a list of the
+             * objects that were returned in the intervening channellist_item
+             * events.
+             *
+             * This data is also available via the Client.channellist property
+             * after this event has fired.
+             */
+            export interface IChannelList {
+                /**
+                 * @param list - channels
+                 */
+                (
+                    list: IChannel[]
+                ): void;
+            }
+
+            /**
+             * 'raw': Emitted when ever the client receives a “message” from
+             * the server. A message is a parsed line from the server.
+             */
+            export interface IRaw {
+                /**
+                 * @param message - raw message
+                 */
+                (message: IMessage): void;
+            }
+
+            /**
+             * 'error': Emitted when ever the server responds with an error-type message. The message parameter is exactly as in the ‘raw’ event.
+             */
+            export interface IError {
+                /**
+                 * @param message - raw message
+                 */
+                (message: IMessage): void;
+            }
+
+            /**
+             * 'action': Emitted whenever a user performs an action
+             * (e.g. /me waves).
+             */
+            export interface IAction {
+                /**
+                 * @param from - sender
+                 * @param to - reciever
+                 * @param text - text
+                 * @param message - raw message
+                 */
+                (
+                    from: string, to: string, text: string, message: IMessage
+                ): void;
+            }
+        }
+    }
+
+    /** Colors */
+    module NodeIRC.colors {
+        /**
+         * Takes a color by name, text, and optionally what color to return.
+         * @param color - name of color
+         * @param text - text to color
+         * @param reset_color - color to set after text
+         */
+        export function wrap(
+            color: string, text: string, reset_color?: string
+        ): string;
+
+        /**
+         * This contains the set of colors available and a function to wrap
+         * text in a color.
+         */
+        export var codes: {
+            [index: string]: string;
+        };
+    }
+
+    export = NodeIRC;
+}