Merge remote-tracking branch 'upstream/master'

CONTRIBUTORS.md

@@ -1,6 +1,6 @@
 # Contributors
 
-This is a non-exhaustive list of definitions and their creators. If you created a definition but are not listed then feel free to send a pull request on this file with your name and url. 
+This is a non-exhaustive list of definitions and their creators. If you created a definition but are not listed then feel free to send a pull request on this file with your name and url.
 
 All definitions files include a header with the author and editors, so at some point this list will be auto-generated.
 
@@ -20,6 +20,7 @@ All definitions files include a header with the author and editors, so at some p
 * [assert](https://github.com/Jxck/assert) (by [vvakame](https://github.com/vvakame))
 * [async](https://github.com/caolan/async) (by [Boris Yankov](https://github.com/borisyankov))
 * [Atom](https://atom.io/) (by [vvakame](https://github.com/vvakame))
+* [aws-sdk-js](https://github.com/aws/aws-sdk-js) (by [midknight41](https://github.com/midknight41))
 * [Backbone.js](http://backbonejs.org/) (by [Boris Yankov](https://github.com/borisyankov))
 * [Backbone Relational](http://backbonerelational.org/) (by [Eirik Hoem](https://github.com/eirikhm))
 * [BigInteger](https://github.com/peterolson/BigInteger.js) (by [Ingo Bürk](https://github.com/Airblader))
@@ -76,6 +77,7 @@ All definitions files include a header with the author and editors, so at some p
 * [Flight by Twitter](http://flightjs.github.com/flight/) (by [Jonathan Hedrén](https://github.com/jonathanhedren))
 * [Foundation](http://foundation.zurb.com/) (by [Boris Yankov](https://github.com/borisyankov))
 * [FPSMeter](http://darsa.in/fpsmeter/) (by [Aaron Lampros](https://github.com/alampros))
+* [fs-extra](https://github.com/jprichardson/node-fs-extra) (by [midknight41](https://github.com/midknight41))
 * [FullCalendar](http://arshaw.com/fullcalendar/) (by [Neil Stalker](https://github.com/nestalk))
 * [Gamepad](http://www.w3.org/TR/gamepad/) (by [Kon](http://phyzkit.net/))
 * [Giraffe](https://github.com/barc/backbone.giraffe) (by [Matt McCray](https://github.com/darthapo))
@@ -107,6 +109,7 @@ All definitions files include a header with the author and editors, so at some p
 * [i18next](http://i18next.com/) (by [Maarten Docter](https://github.com/mdocter))
 * [iCheck](http://damirfoy.com/iCheck/) (by [Dániel Tar](https://github.com/qcz))
 * [Impress.js](https://github.com/bartaz/impress.js) (by [Boris Yankov](https://github.com/borisyankov))
+* [Imagemagick](http://github.com/rsms/node-imagemagick) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [iScroll](http://cubiq.org/iscroll-4) (by [Boris Yankov](https://github.com/borisyankov) and [Christiaan Rakowski](https://github.com/csrakowski))
 * [IxJS (Interactive extensions)](https://github.com/Reactive-Extensions/IxJS) (by [Igor Oleinikov](https://github.com/Igorbek))
 * [jake](https://github.com/mde/jake) (by [Kon](http://phyzkit.net/))
@@ -131,6 +134,7 @@ All definitions files include a header with the author and editors, so at some p
 * [jQuery.dataTables](http://www.datatables.net) (by [Armin Sander](https://github.com/pragmatrix))
 * [jQuery.datetimepicker](http://trentrichardson.com/examples/timepicker/) (by [Doug McDonald](https://github.com/dougajmcdonald))
 * [jQuery.dynatree](http://code.google.com/p/dynatree/) (by [François de Campredon](https://github.com/fdecampredon))
+* [jQuery.Finger](http://ngryman.sh/jquery.finger/) (by [Max Ackley](https://github.com/maxackley))
 * [jQuery.Flot](http://www.flotcharts.org/) (by [Matt Burland](https://github.com/burlandm))
 * [jQuery.form](http://malsup.com/jquery/form/) (by [François Guillot](http://fguillot.developpez.com/))
 * [jQuery.Globalize](https://github.com/jquery/globalize) (by [Boris Yankov](https://github.com/borisyankov))
@@ -156,6 +160,7 @@ All definitions files include a header with the author and editors, so at some p
 * [jQuery.Watermark](http://jquery-watermark.googlecode.com) (by [Anwar Javed](https://github.com/anwarjaved))
 * [jQuery.base64](https://github.com/yatt/jquery.base64) (by [Shinya Mochizuki](https://github.com/enrapt-mochizuki))
 * [js-git](https://github.com/creationix/js-git) (by [Bart van der Schoor](https://github.com/Bartvds))
+* [js-url](https://github.com/websanova/js-url) (by [MIZUNE Pine](https://github.com/pine613))
 * [js-yaml](https://github.com/nodeca/js-yaml) (by [Bart van der Schoor](https://github.com/Bartvds/))
 * [jScrollPane](http://jscrollpane.kelvinluck.com) (by [Dániel Tar](https://github.com/qcz))
 * [JSDeferred](http://cho45.stfuawsc.com/jsdeferred/) (by [Daisuke Mino](https://github.com/minodisk))
@@ -201,16 +206,22 @@ All definitions files include a header with the author and editors, so at some p
 * [Mousetrap](http://craig.is/killing/mice) (by [Dániel Tar](https://github.com/qcz))
 * [msgpack.js](https://github.com/uupaa/msgpack.js) (by [Shinya Mochizuki](https://github.com/enrapt-mochizuki))
 * [Mustache.js](https://github.com/janl/mustache.js) (by [Boris Yankov](https://github.com/borisyankov))
+* [nconf](https://github.com/flatiron/nconf) (by [Jeff Goddard](https://github.com/jedigo))
+* [noble](https://github.com/sandeepmistry/noble) (by [Seon-Wook Park](https://github.com/swook))
+* [nock](https://github.com/pgte/nock) (by [bonnici](https://github.com/bonnici))
 * [Node.js](http://nodejs.org/) (from TypeScript samples)
 * [node_redis](https://github.com/mranney/node_redis) (by [Boris Yankov](https://github.com/borisyankov))
 * [node-ffi](https://github.com/rbranson/node-ffi) (by [Paul Loyd](https://github.com/loyd))
 * [node-git](https://github.com/christkv/node-git) (by [vvakame](https://github.com/vvakame))
+* [nodeunit](https://github.com/caolan/nodeunit) (by [Jeff Goddard](https://github.com/jedigo))
 * [node_zeromq](https://github.com/JustinTulloss/zeromq.node) (by [Dave McKeown](https://github.com/davemckeown))
 * [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) (by [Boris Yankov](https://github.com/borisyankov))
+* [node-uuid](https://github.com/broofa/node-uuid) (by [Jeff May](https://github.com/jeffmay))
 * [notify.js](https://github.com/alexgibson/notify.js) (by [soundTricker](https://github.com/soundTricker))
 * [NProgress](https://github.com/rstacruz/nprogress) (by [Judah Gabriel Himango](https://github.com/judahgabriel))
 * [Numeral.js](https://github.com/adamwdraper/Numeral-js) (by [Vincent Bortone](https://github.com/vbortone/))
 * [OpenLayers](https://github.com/openlayers/openlayers) (by [Ilya Bolkhovsky](https://github.com/bolhovsky/))
+* [Optimist](https://github.com/substack/node-optimist) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [Passport](http://passportjs.org/) (by [Hiroki Horiuchi](https://github.com/horiuchi/))
 * [pathwatcher](http://atom.github.io/node-pathwatcher/) (by [vvakame](https://github.com/vvakame))
 * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin))
@@ -231,6 +242,8 @@ All definitions files include a header with the author and editors, so at some p
 * [Rickshaw](http://code.shutterstock.com/rickshaw/) (by [Blake Niemyjski](https://github.com/niemyjski))
 * [Riot.js](https://github.com/moot/riotjs) (by [vvakame](https://github.com/vvakame))
 * [Restify](https://github.com/mcavage/node-restify) (by [Bret Little](https://github.com/blittle))
+* [Redis](https://github.com/mranney/node_redis) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
+* [Request](https://github.com/mikeal/request) (by [Carlos Ballesteros Velasco](https://github.com/soywiz))
 * [Royalslider](http://dimsemenov.com/plugins/royal-slider/) (by [Christiaan Rakowski](https://github.com/csrakowski))
 * [Rx.js](http://rx.codeplex.com/) (by [gsino](http://www.codeplex.com/site/users/view/gsino), [Igor Oleinikov](https://github.com/Igorbek), [Carl de Billy](http://carl.debilly.net/), [zoetrope](https://github.com/zoetrope))
 * [Raphael](http://raphaeljs.com/) (by [CheCoxshall](https://github.com/CheCoxshall))
@@ -257,6 +270,7 @@ All definitions files include a header with the author and editors, so at some p
 * [Sugar](http://sugarjs.com/) (by [Josh Baldwin](https://github.com/jbaldwin/))
 * [Swiper](http://www.idangero.us/sliders/swiper) (by [Sebastián Galiano](https://github.com/sgaliano))
 * [SwipeView](http://cubiq.org/swipeview) (by [Boris Yankov](https://github.com/borisyankov))
+* [Swiz](https://github.com/racker/node-swiz) (by [Jeff Goddard](https://github.com/jedigo))
 * [TV4](https://github.com/geraintluff/tv4) (by [Bart van der Schoor](https://github.com/Bartvds))
 * [Tags Manager](http://welldonethings.com/tags/manager) (by [Vincent Bortone](https://github.com/vbortone))
 * [Teechart](http://www.steema.com) (by [Steema](http://www.steema.com))

atpl/atpl-tests.ts

@@ -0,0 +1,25 @@
+/// <reference path="atpl.d.ts" />
+
+import atpl = require('atpl');
+
+var bool: boolean;
+var str: string;
+var err: Error;
+var items: any;
+var options: Object;
+var callback: Function;
+
+atpl.compile(str, options);
+atpl.__express(str, options, callback);
+
+atpl.registerExtension(items);
+atpl.registerTags(items);
+atpl.registerFunctions(items);
+atpl.registerFilters(items);
+atpl.registerTests(items);
+
+atpl.registerTags(null);
+atpl.renderFile(str, str, options, bool, (e, res?) => {
+	err = err;
+	str = res;
+});

atpl/atpl.d.ts

@@ -0,0 +1,20 @@
+// Type definitions for atpl
+// Project: https://github.com/soywiz/atpl.js
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/atpl.d.ts
+
+declare module "atpl" {
+	export function compile(templateString: string, options: any): (context:any) => string;
+	export function __express(filename: string, options: any, callback: Function): any;
+
+	export function registerExtension(items: any): void;
+	export function registerTags(items: any): void;
+	export function registerFunctions(items: any): void;
+	export function registerFilters(items: any): void;
+	export function registerTests(items: any): void;
+
+	export function renderFileSync(viewsPath: string, filename: string, parameters: any, cache: boolean ): string;
+	export function renderFile(viewsPath: string, filename: string, parameters: any, cache: boolean, done: (err: Error, result?: string) => void): void;
+}

aws-sdk/aws-sdk-tests.ts

@@ -0,0 +1,13 @@
+/// <reference path="aws-sdk.d.ts" />
+
+import awsSdk = require('aws-sdk');
+
+var str: string;
+
+var creds: awsSdk.Credentials;
+
+creds = new awsSdk.Credentials(str, str);
+creds = new awsSdk.Credentials(str, str, str);
+str = creds.accessKeyId;
+
+// more

aws-sdk/aws-sdk.d.ts

@@ -0,0 +1,909 @@
+// Type definitions for aws-sdk
+// Project: https://github.com/aws/aws-sdk-js
+// Definitions by: midknight41 <https://github.com/midknight41>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/aws-sdk.d.ts
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "aws-sdk" {
+
+	export var config: ClientConfig;
+
+	export function Config(json: any): void;
+
+	export class Credentials {
+		constructor(accessKeyId: string, secretAccessKey: string, sessionToken?: string);
+		accessKeyId: string;
+	}
+
+	export interface ClientConfig {
+		credentials: Credentials;
+		region: string;
+	}
+
+	export class SQS {
+		constructor(options?: any);
+		public client: Sqs.Client;
+	}
+
+	export class SES {
+		constructor(options?: any);
+		public client: Ses.Client;
+	}
+
+	export class SNS {
+		constructor(options?: any);
+		public client: Sns.Client;
+	}
+
+	export class SimpleWorkflow {
+		constructor(options?: any);
+		public client: Swf.Client;
+	}
+
+	export class S3 {
+		constructor(options?: any);
+		public client: s3.Client;
+	}
+
+	export module Sqs {
+
+		export interface Client {
+			config: ClientConfig;
+
+			sendMessage(params: SendMessageRequest, callback: (err: any, data: SendMessageResult) => void): void;
+			sendMessageBatch(params: SendMessageBatchRequest, callback: (err: any, data: SendMessageBatchResult) => void): void;
+			receiveMessage(params: ReceiveMessageRequest, callback: (err: any, data: ReceiveMessageResult) => void): void;
+			deleteMessage(params: DeleteMessageRequest, callback: (err: any, data: any) => void): void;
+			deleteMessageBatch(params: DeleteMessageBatchRequest, callback: (err: any, data: DeleteMessageBatchResult) => void): void;
+			createQueue(params: CreateQueueRequest, callback: (err: any, data: CreateQueueResult) => void): void;
+			deleteQueue(params: DeleteQueueRequest, callback: (err: any, data: any) => void): void;
+		}
+
+		export interface SendMessageRequest {
+			QueueUrl?: string;
+			MessageBody?: string;
+			DelaySeconds?: number;
+		}
+
+		export interface ReceiveMessageRequest {
+			QueueUrl?: string;
+			MaxNumberOfMessages?: number;
+			VisibilityTimeout?: number;
+			AttributeNames?: string[];
+		}
+
+		export interface DeleteMessageBatchRequest {
+			QueueUrl?: string;
+			Entries?: DeleteMessageBatchRequestEntry[];
+		}
+
+		export interface DeleteMessageBatchRequestEntry {
+			Id: string;
+			ReceiptHandle: string;
+		}
+
+		export interface DeleteMessageRequest {
+			QueueUrl?: string;
+			ReceiptHandle?: string;
+		}
+
+		export class Attribute {
+			Name: string;
+			Value: string;
+		}
+
+		export interface SendMessageBatchRequest {
+			QueueUrl?: string;
+			Entries?: SendMessageBatchRequestEntry[];
+		}
+
+		export class SendMessageBatchRequestEntry {
+			Id: string;
+			MessageBody: string;
+			DelaySeconds: number;
+		}
+
+		export interface CreateQueueRequest {
+			QueueName?: string;
+			DefaultVisibilityTimeout?: number;
+			DelaySeconds?: number;
+			Attributes?: Attribute[];
+		}
+
+		export interface DeleteQueueRequest {
+			QueueUrl?: string;
+		}
+
+		export class SendMessageResult {
+			MessageId: string;
+			MD5OfMessageBody: string;
+		}
+
+		export class ReceiveMessageResult {
+			Messages: Message[];
+		}
+
+		export class Message {
+			MessageId: string;
+			ReceiptHandle: string;
+			MD5OfBody: string;
+			Body: string;
+			Attributes: Attribute[];
+		}
+
+		export class DeleteMessageBatchResult {
+			Successful: DeleteMessageBatchResultEntry[];
+			Failed: BatchResultErrorEntry[];
+		}
+
+		export class DeleteMessageBatchResultEntry {
+			Id: string;
+		}
+
+		export class BatchResultErrorEntry {
+			Id: string;
+			Code: string;
+			Message: string;
+			SenderFault: string;
+		}
+
+		export class SendMessageBatchResult {
+			Successful: SendMessageBatchResultEntry[];
+			Failed: BatchResultErrorEntry[];
+		}
+
+		export class SendMessageBatchResultEntry {
+			Id: string;
+			MessageId: string;
+			MD5OfMessageBody: string;
+		}
+
+		export class CreateQueueResult {
+			QueueUrl: string;
+		}
+
+	}
+
+	export module Ses {
+
+		export interface Client {
+			config: ClientConfig;
+
+			sendEmail(params: any, callback: (err: any, data: SendEmailResult) => void): void;
+		}
+
+		export interface SendEmailRequest {
+			Source: string;
+			Destination: Destination;
+			Message: Message;
+			ReplyToAddresses: string[];
+			ReturnPath: string;
+		}
+
+		export class Destination {
+			ToAddresses: string[];
+			CcAddresses: string[];
+			BccAddresses: string[];
+		}
+
+		export class Message {
+			Subject: Content;
+			Body: Body;
+		}
+
+		export class Content {
+			Data: string;
+			Charset: string;
+		}
+
+		export class Body {
+			Text: Content;
+			Html: Content;
+		}
+
+		export class SendEmailResult {
+			MessageId: string;
+		}
+
+	}
+
+	export module Swf {
+
+		export class Client {
+			//constructor(options?: any);
+			public config: ClientConfig;
+
+			countClosedWorkflowExecutions(params: any, callback: (err: any, data: any) => void): void;
+			countOpenWorkflowExecutions(params: any, callback: (err: any, data: any) => void): void;
+			countPendingActivityTasks(params: any, callback: (err: any, data: any) => void): void;
+			countPendingDecisionTasks(params: any, callback: (err: any, data: any) => void): void;
+			deprecateActivityType(params: any, callback: (err: any, data: any) => void): void;
+			deprecateDomain(params: any, callback: (err: any, data: any) => void): void;
+			deprecateWorkflowType(params: any, callback: (err: any, data: any) => void): void;
+			describeActivityType(params: any, callback: (err: any, data: any) => void): void;
+			describeDomain(params: any, callback: (err: any, data: any) => void): void;
+			describeWorkflowExecution(params: any, callback: (err: any, data: any) => void): void;
+			describeWorkflowType(params: any, callback: (err: any, data: any) => void): void;
+			getWorkflowExecutionHistory(params: any, callback: (err: any, data: any) => void): void;
+			listActivityTypes(params: any, callback: (err: any, data: any) => void): void;
+			listClosedWorkflowExecutions(params: any, callback: (err: any, data: any) => void): void;
+			listDomains(params: any, callback: (err: any, data: any) => void): void;
+			listOpenWorkflowExecutions(params: any, callback: (err: any, data: any) => void): void;
+			listWorkflowTypes(params: any, callback: (err: any, data: any) => void): void;
+			pollForActivityTask(params: any, callback: (err: any, data: ActivityTask) => void): void;
+			pollForDecisionTask(params: any, callback: (err: any, data: DecisionTask) => void): void;
+			recordActivityTaskHeartbeat(params: any, callback: (err: any, data: any) => void): void;
+			registerActivityType(params: any, callback: (err: any, data: any) => void): void;
+			registerDomain(params: any, callback: (err: any, data: any) => void): void;
+			registerWorkflowType(params: any, callback: (err: any, data: any) => void): void;
+			requestCancelWorkflowExecution(params: any, callback: (err: any, data: any) => void): void;
+			respondActivityTaskCanceled(params: RespondActivityTaskCanceledRequest, callback: (err: any, data: any) => void): void;
+			respondActivityTaskCompleted(params: RespondActivityTaskCompletedRequest, callback: (err: any, data: any) => void): void;
+			respondActivityTaskFailed(params: RespondActivityTaskFailedRequest, callback: (err: any, data: any) => void): void;
+			respondDecisionTaskCompleted(params: RespondDecisionTaskCompletedRequest, callback: (err: any, data: any) => void): void;
+			signalWorkflowExecution(params: any, callback: (err: any, data: any) => void): void;
+			startWorkflowExecution(params: any, callback: (err: any, data: StartWorkflowExecutionResult) => void): void;
+			terminateWorkflowExecution(params: any, callback: (err: any, data: any) => void): void;
+		}
+
+		export interface PollForActivityTaskRequest {
+			domain?: string;
+			taskList?: TaskList;
+			identity?: string;
+		}
+
+		export interface TaskList {
+			name?: string;
+		}
+
+		export interface PollForDecisionTaskRequest {
+			domain?: string;
+			taskList?: TaskList;
+			identity?: string;
+			nextPageToken?: string;
+			maximumPageSize?: number;
+			reverseOrder?: Boolean;
+		}
+
+		export interface StartWorkflowExecutionRequest {
+			domain?: string;
+			workflowId?: string;
+			workflowType?: WorkflowType;
+			taskList?: TaskList;
+			input?: string;
+			executionStartToCloseTimeout?: string;
+			tagList?: string[];
+			taskStartToCloseTimeout?: string;
+			childPolicy?: string;
+		}
+
+		export interface WorkflowType {
+			name?: string;
+			version?: string;
+		}
+
+		export interface RespondDecisionTaskCompletedRequest {
+			taskToken?: string;
+			decisions?: Decision[];
+			executionContext?: string;
+		}
+
+		export interface Decision {
+			decisionType?: string;
+			scheduleActivityTaskDecisionAttributes?: ScheduleActivityTaskDecisionAttributes;
+			requestCancelActivityTaskDecisionAttributes?: RequestCancelActivityTaskDecisionAttributes;
+			completeWorkflowExecutionDecisionAttributes?: CompleteWorkflowExecutionDecisionAttributes;
+			failWorkflowExecutionDecisionAttributes?: FailWorkflowExecutionDecisionAttributes;
+			cancelWorkflowExecutionDecisionAttributes?: CancelWorkflowExecutionDecisionAttributes;
+			continueAsNewWorkflowExecutionDecisionAttributes?: ContinueAsNewWorkflowExecutionDecisionAttributes;
+			recordMarkerDecisionAttributes?: RecordMarkerDecisionAttributes;
+			startTimerDecisionAttributes?: StartTimerDecisionAttributes;
+			cancelTimerDecisionAttributes?: CancelTimerDecisionAttributes;
+			signalExternalWorkflowExecutionDecisionAttributes?: SignalExternalWorkflowExecutionDecisionAttributes;
+			requestCancelExternalWorkflowExecutionDecisionAttributes?: RequestCancelExternalWorkflowExecutionDecisionAttributes;
+			startChildWorkflowExecutionDecisionAttributes?: StartChildWorkflowExecutionDecisionAttributes;
+		}
+
+		export interface ScheduleActivityTaskDecisionAttributes {
+			activityType?: ActivityType;
+			activityId?: string;
+			control?: string;
+			input?: string;
+			scheduleToCloseTimeout?: string;
+			taskList?: TaskList;
+			scheduleToStartTimeout?: string;
+			startToCloseTimeout?: string;
+			heartbeatTimeout?: string;
+		}
+
+		export interface ActivityType {
+			name?: string;
+			version?: string;
+		}
+
+		export interface RequestCancelActivityTaskDecisionAttributes {
+			activityId?: string;
+		}
+
+		export interface CompleteWorkflowExecutionDecisionAttributes {
+			result?: string;
+		}
+
+		export interface FailWorkflowExecutionDecisionAttributes {
+			reason?: string;
+			details?: string;
+		}
+
+		export interface CancelWorkflowExecutionDecisionAttributes {
+			details?: string;
+		}
+
+		export interface ContinueAsNewWorkflowExecutionDecisionAttributes {
+			input?: string;
+			executionStartToCloseTimeout?: string;
+			taskList?: TaskList;
+			taskStartToCloseTimeout?: string;
+			childPolicy?: string;
+			tagList?: string[];
+			workflowTypeVersion?: string;
+		}
+
+		export interface RecordMarkerDecisionAttributes {
+			markerName?: string;
+			details?: string;
+		}
+
+		export interface StartTimerDecisionAttributes {
+			timerId?: string;
+			control?: string;
+			startToFireTimeout?: string;
+		}
+
+		export interface CancelTimerDecisionAttributes {
+			timerId?: string;
+		}
+
+		export interface SignalExternalWorkflowExecutionDecisionAttributes {
+			workflowId?: string;
+			runId?: string;
+			signalName?: string;
+			input?: string;
+			control?: string;
+		}
+
+		export interface RequestCancelExternalWorkflowExecutionDecisionAttributes {
+			workflowId?: string;
+			runId?: string;
+			control?: string;
+		}
+
+		export interface StartChildWorkflowExecutionDecisionAttributes {
+			workflowType?: WorkflowType;
+			workflowId?: string;
+			control?: string;
+			input?: string;
+			executionStartToCloseTimeout?: string;
+			taskList?: TaskList;
+			taskStartToCloseTimeout?: string;
+			childPolicy?: string;
+			tagList?: string[];
+		}
+
+		export interface RespondActivityTaskCompletedRequest {
+			taskToken?: string;
+			result?: string;
+		}
+
+		export interface RespondActivityTaskFailedRequest {
+			taskToken?: string;
+			reason?: string;
+			details?: string;
+		}
+
+		export interface RespondActivityTaskCanceledRequest {
+			taskToken?: string;
+			details?: string;
+		}
+
+		export interface DecisionTask {
+			taskToken?: string;
+			startedEventId?: number;
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			events?: HistoryEvent[];
+			nextPageToken?: string;
+			previousStartedEventId?: number;
+		}
+
+		export interface WorkflowExecution {
+			workflowId?: string;
+			runId?: string;
+		}
+
+		export interface HistoryEvent {
+			eventTimestamp?: any;
+			eventType?: string;
+			eventId?: number;
+			workflowExecutionStartedEventAttributes?: WorkflowExecutionStartedEventAttributes;
+			workflowExecutionCompletedEventAttributes?: WorkflowExecutionCompletedEventAttributes;
+			completeWorkflowExecutionFailedEventAttributes?: CompleteWorkflowExecutionFailedEventAttributes;
+			workflowExecutionFailedEventAttributes?: WorkflowExecutionFailedEventAttributes;
+			failWorkflowExecutionFailedEventAttributes?: FailWorkflowExecutionFailedEventAttributes;
+			workflowExecutionTimedOutEventAttributes?: WorkflowExecutionTimedOutEventAttributes;
+			workflowExecutionCanceledEventAttributes?: WorkflowExecutionCanceledEventAttributes;
+			cancelWorkflowExecutionFailedEventAttributes?: CancelWorkflowExecutionFailedEventAttributes;
+			workflowExecutionContinuedAsNewEventAttributes?: WorkflowExecutionContinuedAsNewEventAttributes;
+			continueAsNewWorkflowExecutionFailedEventAttributes?: ContinueAsNewWorkflowExecutionFailedEventAttributes;
+			workflowExecutionTerminatedEventAttributes?: WorkflowExecutionTerminatedEventAttributes;
+			workflowExecutionCancelRequestedEventAttributes?: WorkflowExecutionCancelRequestedEventAttributes;
+			decisionTaskScheduledEventAttributes?: DecisionTaskScheduledEventAttributes;
+			decisionTaskStartedEventAttributes?: DecisionTaskStartedEventAttributes;
+			decisionTaskCompletedEventAttributes?: DecisionTaskCompletedEventAttributes;
+			decisionTaskTimedOutEventAttributes?: DecisionTaskTimedOutEventAttributes;
+			activityTaskScheduledEventAttributes?: ActivityTaskScheduledEventAttributes;
+			activityTaskStartedEventAttributes?: ActivityTaskStartedEventAttributes;
+			activityTaskCompletedEventAttributes?: ActivityTaskCompletedEventAttributes;
+			activityTaskFailedEventAttributes?: ActivityTaskFailedEventAttributes;
+			activityTaskTimedOutEventAttributes?: ActivityTaskTimedOutEventAttributes;
+			activityTaskCanceledEventAttributes?: ActivityTaskCanceledEventAttributes;
+			activityTaskCancelRequestedEventAttributes?: ActivityTaskCancelRequestedEventAttributes;
+			workflowExecutionSignaledEventAttributes?: WorkflowExecutionSignaledEventAttributes;
+			markerRecordedEventAttributes?: MarkerRecordedEventAttributes;
+			timerStartedEventAttributes?: TimerStartedEventAttributes;
+			timerFiredEventAttributes?: TimerFiredEventAttributes;
+			timerCanceledEventAttributes?: TimerCanceledEventAttributes;
+			startChildWorkflowExecutionInitiatedEventAttributes?: StartChildWorkflowExecutionInitiatedEventAttributes;
+			childWorkflowExecutionStartedEventAttributes?: ChildWorkflowExecutionStartedEventAttributes;
+			childWorkflowExecutionCompletedEventAttributes?: ChildWorkflowExecutionCompletedEventAttributes;
+			childWorkflowExecutionFailedEventAttributes?: ChildWorkflowExecutionFailedEventAttributes;
+			childWorkflowExecutionTimedOutEventAttributes?: ChildWorkflowExecutionTimedOutEventAttributes;
+			childWorkflowExecutionCanceledEventAttributes?: ChildWorkflowExecutionCanceledEventAttributes;
+			childWorkflowExecutionTerminatedEventAttributes?: ChildWorkflowExecutionTerminatedEventAttributes;
+			signalExternalWorkflowExecutionInitiatedEventAttributes?: SignalExternalWorkflowExecutionInitiatedEventAttributes;
+			externalWorkflowExecutionSignaledEventAttributes?: ExternalWorkflowExecutionSignaledEventAttributes;
+			signalExternalWorkflowExecutionFailedEventAttributes?: SignalExternalWorkflowExecutionFailedEventAttributes;
+			externalWorkflowExecutionCancelRequestedEventAttributes?: ExternalWorkflowExecutionCancelRequestedEventAttributes;
+			requestCancelExternalWorkflowExecutionInitiatedEventAttributes?: RequestCancelExternalWorkflowExecutionInitiatedEventAttributes;
+			requestCancelExternalWorkflowExecutionFailedEventAttributes?: RequestCancelExternalWorkflowExecutionFailedEventAttributes;
+			scheduleActivityTaskFailedEventAttributes?: ScheduleActivityTaskFailedEventAttributes;
+			requestCancelActivityTaskFailedEventAttributes?: RequestCancelActivityTaskFailedEventAttributes;
+			startTimerFailedEventAttributes?: StartTimerFailedEventAttributes;
+			cancelTimerFailedEventAttributes?: CancelTimerFailedEventAttributes;
+			startChildWorkflowExecutionFailedEventAttributes?: StartChildWorkflowExecutionFailedEventAttributes;
+		}
+
+		export interface WorkflowExecutionStartedEventAttributes {
+			input?: string;
+			executionStartToCloseTimeout?: string;
+			taskStartToCloseTimeout?: string;
+			childPolicy?: string;
+			taskList?: TaskList;
+			workflowType?: WorkflowType;
+			tagList?: string[];
+			continuedExecutionRunId?: string;
+			parentWorkflowExecution?: WorkflowExecution;
+			parentInitiatedEventId?: number;
+		}
+
+		export interface WorkflowExecutionCompletedEventAttributes {
+			result?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface CompleteWorkflowExecutionFailedEventAttributes {
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface WorkflowExecutionFailedEventAttributes {
+			reason?: string;
+			details?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface FailWorkflowExecutionFailedEventAttributes {
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface WorkflowExecutionTimedOutEventAttributes {
+			timeoutType?: string;
+			childPolicy?: string;
+		}
+
+		export interface WorkflowExecutionCanceledEventAttributes {
+			details?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface CancelWorkflowExecutionFailedEventAttributes {
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface WorkflowExecutionContinuedAsNewEventAttributes {
+			input?: string;
+			decisionTaskCompletedEventId?: number;
+			newExecutionRunId?: string;
+			executionStartToCloseTimeout?: string;
+			taskList?: TaskList;
+			taskStartToCloseTimeout?: string;
+			childPolicy?: string;
+			tagList?: string[];
+			workflowType?: WorkflowType;
+		}
+
+		export interface ContinueAsNewWorkflowExecutionFailedEventAttributes {
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface WorkflowExecutionTerminatedEventAttributes {
+			reason?: string;
+			details?: string;
+			childPolicy?: string;
+			cause?: string;
+		}
+
+		export interface WorkflowExecutionCancelRequestedEventAttributes {
+			externalWorkflowExecution?: WorkflowExecution;
+			externalInitiatedEventId?: number;
+			cause?: string;
+		}
+
+		export interface DecisionTaskScheduledEventAttributes {
+			taskList?: TaskList;
+			startToCloseTimeout?: string;
+		}
+
+		export interface DecisionTaskStartedEventAttributes {
+			identity?: string;
+			scheduledEventId?: number;
+		}
+
+		export interface DecisionTaskCompletedEventAttributes {
+			executionContext?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface DecisionTaskTimedOutEventAttributes {
+			timeoutType?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ActivityTaskScheduledEventAttributes {
+			activityType?: ActivityType;
+			activityId?: string;
+			input?: string;
+			control?: string;
+			scheduleToStartTimeout?: string;
+			scheduleToCloseTimeout?: string;
+			startToCloseTimeout?: string;
+			taskList?: TaskList;
+			decisionTaskCompletedEventId?: number;
+			heartbeatTimeout?: string;
+		}
+
+		export interface ActivityTaskStartedEventAttributes {
+			identity?: string;
+			scheduledEventId?: number;
+		}
+
+		export interface ActivityTaskCompletedEventAttributes {
+			result?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ActivityTaskFailedEventAttributes {
+			reason?: string;
+			details?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ActivityTaskTimedOutEventAttributes {
+			timeoutType?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+			details?: string;
+		}
+
+		export interface ActivityTaskCanceledEventAttributes {
+			details?: string;
+			scheduledEventId?: number;
+			startedEventId?: number;
+			latestCancelRequestedEventId?: number;
+		}
+
+		export interface ActivityTaskCancelRequestedEventAttributes {
+			decisionTaskCompletedEventId?: number;
+			activityId?: string;
+		}
+
+		export interface WorkflowExecutionSignaledEventAttributes {
+			signalName?: string;
+			input?: string;
+			externalWorkflowExecution?: WorkflowExecution;
+			externalInitiatedEventId?: number;
+		}
+
+		export interface MarkerRecordedEventAttributes {
+			markerName?: string;
+			details?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface TimerStartedEventAttributes {
+			timerId?: string;
+			control?: string;
+			startToFireTimeout?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface TimerFiredEventAttributes {
+			timerId?: string;
+			startedEventId?: number;
+		}
+
+		export interface TimerCanceledEventAttributes {
+			timerId?: string;
+			startedEventId?: number;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface StartChildWorkflowExecutionInitiatedEventAttributes {
+			workflowId?: string;
+			workflowType?: WorkflowType;
+			control?: string;
+			input?: string;
+			executionStartToCloseTimeout?: string;
+			taskList?: TaskList;
+			decisionTaskCompletedEventId?: number;
+			childPolicy?: string;
+			taskStartToCloseTimeout?: string;
+			tagList?: string[];
+		}
+
+		export interface ChildWorkflowExecutionStartedEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			initiatedEventId?: number;
+		}
+
+		export interface ChildWorkflowExecutionCompletedEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			result?: string;
+			initiatedEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ChildWorkflowExecutionFailedEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			reason?: string;
+			details?: string;
+			initiatedEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ChildWorkflowExecutionTimedOutEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			timeoutType?: string;
+			initiatedEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ChildWorkflowExecutionCanceledEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			details?: string;
+			initiatedEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface ChildWorkflowExecutionTerminatedEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			workflowType?: WorkflowType;
+			initiatedEventId?: number;
+			startedEventId?: number;
+		}
+
+		export interface SignalExternalWorkflowExecutionInitiatedEventAttributes {
+			workflowId?: string;
+			runId?: string;
+			signalName?: string;
+			input?: string;
+			decisionTaskCompletedEventId?: number;
+			control?: string;
+		}
+
+		export interface ExternalWorkflowExecutionSignaledEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			initiatedEventId?: number;
+		}
+
+		export interface SignalExternalWorkflowExecutionFailedEventAttributes {
+			workflowId?: string;
+			runId?: string;
+			cause?: string;
+			initiatedEventId?: number;
+			decisionTaskCompletedEventId?: number;
+			control?: string;
+		}
+
+		export interface ExternalWorkflowExecutionCancelRequestedEventAttributes {
+			workflowExecution?: WorkflowExecution;
+			initiatedEventId?: number;
+		}
+
+		export interface RequestCancelExternalWorkflowExecutionInitiatedEventAttributes {
+			workflowId?: string;
+			runId?: string;
+			decisionTaskCompletedEventId?: number;
+			control?: string;
+		}
+
+		export interface RequestCancelExternalWorkflowExecutionFailedEventAttributes {
+			workflowId?: string;
+			runId?: string;
+			cause?: string;
+			initiatedEventId?: number;
+			decisionTaskCompletedEventId?: number;
+			control?: string;
+		}
+
+		export interface ScheduleActivityTaskFailedEventAttributes {
+			activityType?: ActivityType;
+			activityId?: string;
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface RequestCancelActivityTaskFailedEventAttributes {
+			activityId?: string;
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface StartTimerFailedEventAttributes {
+			timerId?: string;
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface CancelTimerFailedEventAttributes {
+			timerId?: string;
+			cause?: string;
+			decisionTaskCompletedEventId?: number;
+		}
+
+		export interface StartChildWorkflowExecutionFailedEventAttributes {
+			workflowType?: WorkflowType;
+			cause?: string;
+			workflowId?: string;
+			initiatedEventId?: number;
+			decisionTaskCompletedEventId?: number;
+			control?: string;
+		}
+
+		export interface ActivityTask {
+			taskToken?: string;
+			activityId?: string;
+			startedEventId?: number;
+			workflowExecution?: WorkflowExecution;
+			activityType?: ActivityType;
+			input?: string;
+		}
+
+		export interface PollForActivityTaskResult {
+			activityTask?: ActivityTask;
+		}
+
+		export interface PollForDecisionTaskResult {
+			decisionTask?: DecisionTask;
+		}
+
+		export interface StartWorkflowExecutionResult {
+			run?: Run;
+		}
+
+		export interface Run {
+			runId?: string;
+		}
+
+	}
+
+	export module Sns {
+
+		export interface Client {
+			config: ClientConfig;
+
+			publicTopic(params: PublishRequest, callback: (err: any, data: PublishResult) => void): void;
+			createTopic(params: CreateTopicRequest, callback: (err: any, data: CreateTopicResult) => void): void;
+			deleteTopic(params: DeleteTopicRequest, callback: (err: any, data: any) => void): void;
+		}
+
+		export interface PublishRequest {
+			TopicArn?: string;
+			Message?: string;
+			MessageStructure?: string;
+			Subject?: string;
+		}
+
+		export interface PublishResult {
+			MessageId?: string;
+		}
+
+		export interface CreateTopicRequest {
+			Name?: string;
+		}
+
+		export interface CreateTopicResult {
+			TopicArn?: string;
+		}
+
+		export interface DeleteTopicRequest {
+			TopicArn?: string;
+		}
+
+	}
+
+	export module s3 {
+
+		export interface Client {
+			config: ClientConfig;
+
+			putObject(params: PutObjectRequest, callback: (err: any, data: any) => void): void;
+			getObject(params: GetObjectRequest, callback: (err: any, data: any) => void): void;
+		}
+
+		export interface PutObjectRequest {
+			ACL?: string;
+			Body?: any;
+			Bucket: string;
+			CacheControl?: string;
+			ContentDisposition?: string;
+			ContentEncoding?: string;
+			ContentLanguage?: string;
+			ContentLength?: string;
+			ContentMD5?: string;
+			ContentType?: string;
+			Expires?: any;
+			GrantFullControl?: string;
+			GrantRead?: string;
+			GrantReadACP?: string;
+			GrantWriteACP?: string;
+			Key: string;
+			Metadata?: string[];
+			ServerSideEncryption?: string;
+			StorageClass?: string;
+			WebsiteRedirectLocation?: string;
+		}
+
+		export interface GetObjectRequest {
+			Bucket: string;
+			IfMatch?: string;
+			IfModifiedSince?: any;
+			IfNoneMatch?: string;
+			IfUnmodifiedSince?: any;
+			Key: string;
+			Range?: string;
+			ResponseCacheControl?: string;
+			ResponseContentDisposition?: string;
+			ResponseContentEncoding?: string;
+			ResponseContentLanguage?: string;
+			ResponseContentType?: string;
+			ResponseExpires?: any;
+			VersionId?: string;
+		}
+
+	}
+}

browser-harness/browser-harness.d.ts

@@ -6,27 +6,28 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module "browser-harness" {
+    import _events = require('events');
 
-    interface HarnessEvents extends NodeEventEmitter {
-        once(event: string, listener: (driver: Driver) => void): NodeEventEmitter;
-        once(event: 'ready', listener: (driver: Driver) => void): NodeEventEmitter;
+    interface HarnessEvents extends _events.EventEmitter {
+        once(event: string, listener: (driver: Driver) => void): _events.EventEmitter;
+        once(event: 'ready', listener: (driver: Driver) => void): _events.EventEmitter;
 
-        on(event: string, listener: (driver: Driver) => void): NodeEventEmitter;
-        on(event: 'ready', listener: (driver: Driver) => void): NodeEventEmitter;
+        on(event: string, listener: (driver: Driver) => void): _events.EventEmitter;
+        on(event: 'ready', listener: (driver: Driver) => void): _events.EventEmitter;
     }
 
-    interface DriverEvents extends NodeEventEmitter {
-        once(event: string, listener: (text: string) => void): NodeEventEmitter;
-        once(event: 'console.log', listener: (text: string) => void): NodeEventEmitter;
-        once(event: 'console.warn', listener: (text: string) => void): NodeEventEmitter;
-        once(event: 'console.error', listener: (text: string) => void): NodeEventEmitter;
-        once(event: 'window.onerror', listener: (text: string) => void): NodeEventEmitter;
+    interface DriverEvents extends _events.EventEmitter {
+        once(event: string, listener: (text: string) => void): _events.EventEmitter;
+        once(event: 'console.log', listener: (text: string) => void): _events.EventEmitter;
+        once(event: 'console.warn', listener: (text: string) => void): _events.EventEmitter;
+        once(event: 'console.error', listener: (text: string) => void): _events.EventEmitter;
+        once(event: 'window.onerror', listener: (text: string) => void): _events.EventEmitter;
 
-        on(event: string, listener: (text: string) => void): NodeEventEmitter;
-        on(event: 'console.log', listener: (text: string) => void): NodeEventEmitter;
-        on(event: 'console.warn', listener: (text: string) => void): NodeEventEmitter;
-        on(event: 'console.error', listener: (text: string) => void): NodeEventEmitter;
-        on(event: 'window.onerror', listener: (text: string) => void): NodeEventEmitter;
+        on(event: string, listener: (text: string) => void): _events.EventEmitter;
+        on(event: 'console.log', listener: (text: string) => void): _events.EventEmitter;
+        on(event: 'console.warn', listener: (text: string) => void): _events.EventEmitter;
+        on(event: 'console.error', listener: (text: string) => void): _events.EventEmitter;
+        on(event: 'window.onerror', listener: (text: string) => void): _events.EventEmitter;
     }
 
     export interface Driver {

browserify/browserify.d.ts

@@ -5,7 +5,7 @@
 
 /// <reference path="../node/node.d.ts" />
 
-interface BrowserifyObject extends NodeEventEmitter {
+interface BrowserifyObject extends NodeJS.EventEmitter {
 	add(file: string): BrowserifyObject;
 	require(file: string, opts?: {
 		expose: string;
@@ -16,7 +16,7 @@ interface BrowserifyObject extends NodeEventEmitter {
 		debug?: boolean;
 		standalone?: string;
 		insertGlobalVars?: any;
-	}, cb?: (err: any, src: any) => void): ReadableStream;
+	}, cb?: (err: any, src: any) => void): NodeJS.ReadableStream;
 
 	external(file: string): BrowserifyObject;
 	ignore(file: string): BrowserifyObject;

buffer-equal/buffer-equal-tests.ts

@@ -3,6 +3,6 @@
 import bufferEqual = require('buffer-equal');
 
 var bool: boolean;
-var buf: NodeBuffer;
+var buf: Buffer;
 
 bool = bufferEqual(buf, buf);

buffer-equal/buffer-equal.d.ts

@@ -6,6 +6,6 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module 'buffer-equal' {
-	function bufferEqual(actual:NodeBuffer, expected:NodeBuffer): boolean;
+	function bufferEqual(actual:Buffer, expected:Buffer): boolean;
 	export = bufferEqual;
 }

consolidate/consolidate-tests.ts

@@ -0,0 +1,27 @@
+/// <reference path="consolidate.d.ts" />
+
+import consolidate = require('consolidate');
+
+var path: string = null;
+var options: any = null;
+var fn: any = null;
+
+consolidate.clearCache();
+consolidate.jade(path, options, fn);
+consolidate.dust(path, options, fn);
+consolidate.swig(path, options, fn);
+consolidate.liquor(path, options, fn);
+consolidate.ejs(path, options, fn);
+consolidate.eco(path, options, fn);
+consolidate.jazz(path, options, fn);
+consolidate.jqtpl(path, options, fn);
+consolidate.haml(path, options, fn);
+consolidate.whiskers(path, options, fn);
+//consolidate.'haml-coffee':Function;
+consolidate.hogan(path, options, fn);
+consolidate.handlebars(path, options, fn);
+consolidate.underscore(path, options, fn);
+consolidate.qejs(path, options, fn);
+consolidate.walrus(path, options, fn);
+consolidate.mustache(path, options, fn);
+consolidate.dot(path, options, fn);

consolidate/consolidate.d.ts

@@ -0,0 +1,30 @@
+// Type definitions for consolidate
+// Project: https://github.com/visionmedia/consolidate.js
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/consolidate.d.ts
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "consolidate" {
+	export function clearCache(): void;
+	export var jade: (path: String, options: any, fn: any) => void;
+	export var dust: (path: String, options: any, fn: any) => void;
+	export var swig: (path: String, options: any, fn: any) => void;
+	export var liquor: (path: String, options: any, fn: any) => void;
+	export var ejs: (path: String, options: any, fn: any) => void;
+	export var eco: (path: String, options: any, fn: any) => void;
+	export var jazz: (path: String, options: any, fn: any) => void;
+	export var jqtpl: (path: String, options: any, fn: any) => void;
+	export var haml: (path: String, options: any, fn: any) => void;
+	export var whiskers: (path: String, options: any, fn: any) => void;
+	//export var 'haml-coffee':Function;
+	export var hogan: (path: String, options: any, fn: any) => void;
+	export var handlebars: (path: String, options: any, fn: any) => void;
+	export var underscore: (path: String, options: any, fn: any) => void;
+	export var qejs: (path: String, options: any, fn: any) => void;
+	export var walrus: (path: String, options: any, fn: any) => void;
+	export var mustache: (path: String, options: any, fn: any) => void;
+	export var dot: (path: String, options: any, fn: any) => void;
+}

cordova/plugins/Contacts.d.ts

@@ -143,9 +143,9 @@ interface ContactName {
     /** The contact's middle name. */
     middleName?: string;
     /** The contact's prefix (example Mr. or Dr.) */
-    honorifixPrefix?: string;
+    honorificPrefix?: string;
     /** The contact's suffix (example Esq.). */
-    honorifixSuffix?: string;
+    honorificSuffix?: string;
 }
 
 declare var ContactName: {
@@ -154,8 +154,8 @@ declare var ContactName: {
         familyName?: string,
         givenName?: string,
         middleName?: string,
-        honorifixPrefix?: string,
-        honorifixSuffix?: string): ContactName
+        honorificPrefix?: string,
+        honorificSuffix?: string): ContactName
 };
 
 /**
@@ -171,19 +171,19 @@ declare var ContactName: {
  * contains a base64-encoded image string.
  */
 interface ContactField {
-    /** Set to true if this ContactField contains the user's preferred value. */
-    pref: boolean;
     /** A string that indicates what type of field this is, home for example. */
     type: string;
     /** The value of the field, such as a phone number or email address. */
     value: string;
+    /** Set to true if this ContactField contains the user's preferred value. */
+    pref: boolean;
 }
 
 declare var ContactField: {
     /** Constructor for ContactField object */
     new(type?: string,
-        pref?: boolean,
-        value?: string): ContactField
+        value?: string,
+        pref?: boolean): ContactField
 };
 
 /**

cordova/plugins/FileSystem.d.ts

@@ -25,17 +25,7 @@ interface Window {
 
 /** This interface represents a file system. */
 interface FileSystem {
-    /**
-     * Constructor for FileSystem object
-     * @param name This is the name of the file system. The specifics of naming filesystems
-     *             is unspecified, but a name must be unique across the list of exposed file systems.
-     * @param root The root directory of the file system.
-     */
-    new (name: string, root: DirectoryEntry)
-    /**
-     * This is the name of the file system. The specifics of naming filesystems
-     * is unspecified, but a name must be unique across the list of exposed file systems.
-     */
+    /* The name of the file system, unique across the list of exposed file systems. */
     name: string;
     /** The root directory of the file system. */
     root: DirectoryEntry;
@@ -46,8 +36,6 @@ interface FileSystem {
  * each of which may be a File or DirectoryEntry.
  */
 interface Entry {
-    /** Constructor for Entry object */
-    new ( isFile: boolean, isDirectory: boolean, name: string, fullPath: string, fileSystem: FileSystem, nativeURL: string) ;
     /** Entry is a file. */
     isFile: boolean;
     /** Entry is a directory. */
@@ -265,13 +253,13 @@ interface FileSaver extends EventTarget {
  */
 interface FileWriter extends FileSaver {
     /**
-     * The byte offset at which the next write to the file will occur. This must be no greater than length.
-     * A newly-created FileWriter must have position set to 0.
+     * The byte offset at which the next write to the file will occur. This always less or equal than length.
+     * A newly-created FileWriter will have position set to 0.
      */
     position: number;
     /**
      * The length of the file. If the user does not have read access to the file,
-     * this must be the highest byte offset at which the user has written.
+     * this will be the highest byte offset at which the user has written.
      */
     length: number;
     /**
@@ -287,7 +275,7 @@ interface FileWriter extends FileSaver {
     seek(offset: number): void;
     /**
      * Changes the length of the file to that specified. If shortening the file, data beyond the new length
-     * must be discarded. If extending the file, the existing data must be zero-padded up to the new length.
+     * will be discarded. If extending the file, the existing data will be zero-padded up to the new length.
      * @param size The size to which the length of the file is to be adjusted, measured in bytes.
      */
     truncate(size: number): void;

cordova/plugins/Media.d.ts

@@ -27,19 +27,6 @@ declare var Media: {
  * W3C specification and may deprecate the current APIs.
  */
 interface Media {
-    /**
-     * Constructor for Media object.
-     * @param  src          A URI containing the audio content.
-     * @param  mediaSuccess The callback that executes after a Media object has completed
-     *                      the current play, record, or stop action.
-     * @param  mediaError   The callback that executes if an error occurs.
-     * @param  mediaStatus  The callback that executes to indicate status changes.
-     */
-    new (
-        src: string,
-        mediaSuccess: () => void,
-        mediaError?: (error: MediaError) => any,
-        mediaStatus?: (status: number) => void): Media;
     /**
      * Returns the current position within an audio file. Also updates the Media object's position parameter.
      * @param mediaSuccess The callback that is passed the current position in seconds.

cordova/plugins/WebSQL.d.ts

@@ -1,5 +1,5 @@
 // Type definitions for Apache Cordova WebSQL plugin.
-// Project: https://github.com/sgrebnov/cordova-plugin-websql
+// Project: https://github.com/MSOpenTech/cordova-plugin-websql
 // Definitions by: Microsoft Open Technologies, Inc. <http://msopentech.com>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 // 
@@ -43,7 +43,7 @@ interface Database {
         successCallback?: () => void): void;
     name: string;
     version: string;
-    displayname: string;
+    displayName: string;
     size: number;
 }
 

couchbase/couchbase.d.ts

@@ -648,8 +648,8 @@ declare module 'couchbase' {
 
         append(key: string, fragment: string, callback: KeyCallback): void;
         append(key: string, fragment: string, options: AppendOptions, callback: KeyCallback): void;
-        append(key: string, fragment: NodeBuffer, callback: KeyCallback): void;
-        append(key: string, fragment: NodeBuffer, options: AppendOptions, callback: KeyCallback): void;
+        append(key: string, fragment: Buffer, callback: KeyCallback): void;
+        append(key: string, fragment: Buffer, options: AppendOptions, callback: KeyCallback): void;
         appendMulti(kv: { [key: string]: AppendMultiOptionsForValue }, options: AppendMultiOptions, callback: MultiCallback): void;
 
         decr(key: string, callback: KeyCallback): void;
@@ -683,8 +683,8 @@ declare module 'couchbase' {
 
         prepend(key: string, fragment: string, callback: KeyCallback): void;
         prepend(key: string, fragment: string, options: PrependOptions, callback: KeyCallback): void;
-        prepend(key: string, fragment: NodeBuffer, callback: KeyCallback): void;
-        prepend(key: string, fragment: NodeBuffer, options: PrependOptions, callback: KeyCallback): void;
+        prepend(key: string, fragment: Buffer, callback: KeyCallback): void;
+        prepend(key: string, fragment: Buffer, options: PrependOptions, callback: KeyCallback): void;
         prependMulti(kv: { [key: string]: PrependMultiOptionsFoValue }, options: { [key: string]: PrependMultiOptions }, callback: MultiCallback): void;
 
         remove(key: string, callback: KeyCallback): void;

fibers/fibers-tests.ts

@@ -0,0 +1,13 @@
+/// <reference path="fibers.d.ts" />
+
+import fibers = require('fibers');
+
+var fib: fibers.Fiber;
+var x:any = null;
+var func: () => void = null;
+
+fib = fibers(func);
+fib = fibers.current;
+x = fibers.yield(x);
+x = fib.run();
+x = fib.run(x);

fibers/fibers.d.ts

@@ -0,0 +1,24 @@
+// Type definitions for fibers
+// Project: https://github.com/laverdet/node-fibers
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/fibers.d.ts
+
+declare module "fibers" {
+
+	function fibers(callback: () => void): fibers.Fiber;
+
+	module fibers {
+		export var poolSize: number;
+		export var fibersCreated: number;
+		export var current: fibers.Fiber;
+		export function yield(value: any): any;
+
+		export interface Fiber {
+			run(step?: number): any;
+		}
+	}
+
+	export = fibers;
+}

form-data/form-data-tests.ts

@@ -0,0 +1,8 @@
+/// <reference path="form-data.d.ts" />
+
+import formData = require('form-data');
+
+var value: any;
+var fd = new formData.FormData();
+var obj: Object = fd.getHeaders();
+value = fd.pipe(value);

form-data/form-data.d.ts

@@ -0,0 +1,15 @@
+// Type definitions for fibers
+// Project: https://github.com/felixge/node-form-data
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/form-data.d.ts
+
+declare module "form-data" {
+	export class FormData {
+		append(key: string, value: any): FormData;
+		getHeaders(): Object;
+		// TODO expand pipe
+		pipe(to: any): any;
+	}
+}

fs-extra/fs-extra-tests.ts

@@ -0,0 +1,229 @@
+/// <reference path="fs-extra.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import fs = require('fs-extra');
+import stream = require('stream');
+
+var stats: fs.Stats;
+var str: string;
+var strArr: string[];
+var bool: boolean;
+var num: number;
+var src: string;
+var dest: string;
+var file: string;
+var filename: string;
+var dir: string;
+var path: string;
+var data: any;
+var object: Object;
+var buffer: NodeBuffer;
+var modeNum: number;
+var modeStr: string;
+var encoding: string;
+var type: string;
+var flags: string;
+var srcpath: string;
+var dstpath: string;
+var oldPath: string;
+var newPath: string;
+var cache: string;
+var offset: number;
+var length: number;
+var position: number;
+var cacheBool: boolean;
+var cacheStr: string;
+var fd: number;
+var len: number;
+var uid: number;
+var gid: number;
+var atime: number;
+var mtime: number;
+var statsCallback: (err: Error, stats: fs.Stats) => void;
+var errorCallback: (err: Error) => void;
+var openOpts: fs.OpenOptions;
+var watcher: fs.FSWatcher;
+var readStreeam: stream.Readable;
+var writeStream: stream.Writable;
+
+fs.copy(src, dest, errorCallback);
+fs.copy(src, dest, (src: string) => {
+	return false;
+}, errorCallback);
+fs.copySync(src, dest);
+fs.copySync(src, dest, (src: string) => {
+	return false;
+});
+fs.createFile(file, errorCallback);
+fs.createFileSync(file);
+
+fs.mkdirs(dir, errorCallback);
+fs.mkdirsSync(dir);
+fs.mkdirp(dir, errorCallback);
+fs.mkdirpSync(dir);
+
+fs.outputFile(file, data, errorCallback);
+fs.outputFileSync(file, data);
+fs.outputJson(file, data, errorCallback);
+fs.outputJSON(file, data, errorCallback);
+
+fs.outputJsonSync(file, data);
+fs.outputJSONSync(file, data);
+
+fs.readJson(file, errorCallback);
+fs.readJson(file, openOpts, errorCallback);
+fs.readJSON(file, errorCallback);
+fs.readJSON(file, openOpts, errorCallback);
+
+fs.readJsonSync(file, openOpts);
+fs.readJSONSync(file, openOpts);
+
+fs.remove(dir, errorCallback);
+fs.removeSync(dir);
+
+fs.writeJson(file, object, errorCallback);
+fs.writeJson(file, object, openOpts, errorCallback);
+fs.writeJSON(file, object, errorCallback);
+fs.writeJSON(file, object, openOpts, errorCallback);
+
+fs.writeJsonSync(file, object, openOpts);
+fs.writeJSONSync(file, object, openOpts);
+
+fs.rename(oldPath, newPath, errorCallback);
+fs.renameSync(oldPath, newPath);
+fs.truncate(fd, len, errorCallback);
+fs.truncateSync(fd, len);
+fs.chown(path, uid, gid, errorCallback);
+fs.chownSync(path, uid, gid);
+fs.fchown(fd, uid, gid, errorCallback);
+fs.fchownSync(fd, uid, gid);
+fs.lchown(path, uid, gid, errorCallback);
+fs.lchownSync(path, uid, gid);
+fs.chmod(path, modeNum, errorCallback);
+fs.chmod(path, modeStr, errorCallback);
+fs.chmodSync(path, modeNum);
+fs.chmodSync(path, modeStr);
+fs.fchmod(fd, modeNum, errorCallback);
+fs.fchmod(fd, modeStr, errorCallback);
+fs.fchmodSync(fd, modeNum);
+fs.fchmodSync(fd, modeStr);
+fs.lchmod(path, modeStr, errorCallback);
+fs.lchmod(path, modeNum, errorCallback);
+fs.lchmodSync(path, modeNum);
+fs.lchmodSync(path, modeStr);
+fs.stat(path, statsCallback);
+fs.lstat(path, statsCallback);
+fs.fstat(fd, statsCallback);
+stats = fs.statSync(path);
+stats = fs.lstatSync(path);
+stats = fs.fstatSync(fd);
+fs.link(srcpath, dstpath, errorCallback);
+fs.linkSync(srcpath, dstpath);
+fs.symlink(srcpath, dstpath, type, errorCallback);
+fs.symlinkSync(srcpath, dstpath, type);
+fs.readlink(path, (err: Error, linkString: string) => {
+
+});
+fs.realpath(path, (err: Error, resolvedPath: string) => {
+
+});
+fs.realpath(path, cache, (err: Error, resolvedPath: string) => {
+
+});
+str = fs.realpathSync(path, cacheBool);
+fs.unlink(path, errorCallback);
+fs.unlinkSync(path);
+fs.rmdir(path, errorCallback);
+fs.rmdirSync(path);
+fs.mkdir(path, modeNum, errorCallback);
+fs.mkdir(path, modeStr, errorCallback);
+fs.mkdirSync(path, modeNum);
+fs.mkdirSync(path, modeStr);
+fs.readdir(path, (err: Error, files: string[]) => {
+
+});
+strArr = fs.readdirSync(path);
+fs.close(fd, errorCallback);
+fs.closeSync(fd);
+fs.open(path, flags, modeStr, (err: Error, fd: number) => [
+
+]);
+num = fs.openSync(path, flags, modeStr);
+fs.utimes(path, atime, mtime, errorCallback);
+fs.utimesSync(path, atime, mtime);
+fs.futimes(fd, atime, mtime, errorCallback);
+fs.futimesSync(fd, atime, mtime);
+fs.fsync(fd, errorCallback);
+fs.fsyncSync(fd);
+fs.write(fd, buffer, offset, length, position, (err: Error, written: number, buffer: NodeBuffer) => {
+
+});
+num = fs.writeSync(fd, buffer, offset, length, position);
+fs.read(fd, buffer, offset, length, position, (err: Error, bytesRead: number, buffer: NodeBuffer) => {
+
+});
+num = fs.readSync(fd, buffer, offset, length, position);
+fs.readFile(filename, (err: Error, data: NodeBuffer) => {
+
+});
+fs.readFile(filename, encoding, (err: Error, data: string) => {
+
+});
+fs.readFile(filename, openOpts, (err: Error, data: string) => {
+
+});
+fs.readFile(filename, (err: Error, data: NodeBuffer) => {
+
+});
+buffer = fs.readFileSync(filename);
+str = fs.readFileSync(filename, encoding);
+str = fs.readFileSync(filename, openOpts);
+
+fs.writeFile(filename, data, errorCallback);
+fs.writeFile(filename, data, encoding, errorCallback);
+fs.writeFile(filename, data, openOpts, errorCallback);
+fs.writeFileSync(filename, data);
+fs.writeFileSync(filename, data, encoding);
+fs.writeFileSync(filename, data, openOpts);
+
+fs.appendFile(filename, data, errorCallback);
+fs.appendFile(filename, data, encoding, errorCallback);
+fs.appendFile(filename, data, openOpts, errorCallback);
+fs.appendFileSync(filename, data);
+fs.appendFileSync(filename, data, encoding);
+fs.appendFileSync(filename, data, openOpts);
+
+fs.watchFile(filename, {
+	curr: stats,
+	prev: stats
+});
+fs.watchFile(filename, {
+	persistent: bool,
+	interval: num
+}, {
+	curr: stats,
+	prev: stats
+});
+fs.unwatchFile(filename);
+watcher = fs.watch(filename, { persistent: bool }, (event: string, filename: string) => {
+
+});
+fs.exists(path, (exists: boolean) => {
+
+});
+bool = fs.existsSync(path);
+
+readStreeam = fs.createReadStream(path);
+readStreeam = fs.createReadStream(path, {
+	flags: str,
+	encoding: str,
+	fd: num,
+	mode: num,
+	bufferSize: num
+});
+writeStream = fs.createWriteStream(path);
+writeStream = fs.createWriteStream(path, {
+	flags: str,
+	encoding: str,
+	string: str
+});

fs-extra/fs-extra.d.ts

@@ -0,0 +1,187 @@
+// Type definitions for aws-sdk
+// Project: https://github.com/jprichardson/node-fs-extra
+// Definitions by: midknight41 <https://github.com/midknight41>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/fs-extra.d.ts
+
+///<reference path="../node/node.d.ts"/>
+
+declare module "fs-extra" {
+	import stream = require("stream");
+
+	export 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;
+	}
+
+	export interface FSWatcher {
+		close(): void;
+	}
+
+	export class ReadStream extends stream.Readable { }
+	export class WriteStream extends stream.Writable { }
+
+	//extended methods
+	export function copy(src: string, dest: string, callback?: (err: Error) => void): void;
+	export function copy(src: string, dest: string, filter: (src: string) => boolean, callback?: (err: Error) => void): void;
+
+	export function copySync(src: string, dest: string): void;
+	export function copySync(src: string, dest: string, filter: (src: string) => boolean): void;
+
+	export function createFile(file: string, callback?: (err: Error) => void): void;
+	export function createFileSync(file: string): void;
+
+	export function mkdirs(dir: string, callback?: (err: Error) => void): void;
+	export function mkdirp(dir: string, callback?: (err: Error) => void): void;
+	export function mkdirsSync(dir: string): void;
+	export function mkdirpSync(dir: string): void;
+
+	export function outputFile(file: string, data: any, callback?: (err: Error) => void): void;
+	export function outputFileSync(file: string, data: any): void;
+
+	export function outputJson(file: string, data: any, callback?: (err: Error) => void): void;
+	export function outputJSON(file: string, data: any, callback?: (err: Error) => void): void;
+	export function outputJsonSync(file: string, data: any): void;
+	export function outputJSONSync(file: string, data: any): void;
+
+	export function readJson(file: string, callback?: (err: Error) => void): void;
+	export function readJson(file: string, options?: OpenOptions, callback?: (err: Error) => void): void;
+	export function readJSON(file: string, callback?: (err: Error) => void): void;
+	export function readJSON(file: string, options?: OpenOptions, callback?: (err: Error) => void): void;
+
+	export function readJsonSync(file: string, options?: OpenOptions): void;
+	export function readJSONSync(file: string, options?: OpenOptions): void;
+
+	export function remove(dir: string, callback?: (err: Error) => void): void;
+	export function removeSync(dir: string): void;
+	// export function delete(dir: string, callback?: (err: Error) => void): void;
+	// export function deleteSync(dir: string): void;
+
+	export function writeJson(file: string, object: any, callback?: (err: Error) => void): void;
+	export function writeJson(file: string, object: any, options?: OpenOptions, callback?: (err: Error) => void): void;
+	export function writeJSON(file: string, object: any, callback?: (err: Error) => void): void;
+	export function writeJSON(file: string, object: any, options?: OpenOptions, callback?: (err: Error) => void): void;
+
+	export function writeJsonSync(file: string, object: any, options?: OpenOptions): void;
+	export function writeJSONSync(file: string, object: any, options?: OpenOptions): void;
+
+	export function rename(oldPath: string, newPath: string, callback?: (err: Error) => void): void;
+	export function renameSync(oldPath: string, newPath: string): void;
+	export function truncate(fd: number, len: number, callback?: (err: Error) => void): void;
+	export function truncateSync(fd: number, len: number): void;
+	export function chown(path: string, uid: number, gid: number, callback?: (err: Error) => void): void;
+	export function chownSync(path: string, uid: number, gid: number): void;
+	export function fchown(fd: number, uid: number, gid: number, callback?: (err: Error) => void): void;
+	export function fchownSync(fd: number, uid: number, gid: number): void;
+	export function lchown(path: string, uid: number, gid: number, callback?: (err: Error) => void): void;
+	export function lchownSync(path: string, uid: number, gid: number): void;
+	export function chmod(path: string, mode: number, callback?: (err: Error) => void): void;
+	export function chmod(path: string, mode: string, callback?: (err: Error) => 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: Error) => void): void;
+	export function fchmod(fd: number, mode: string, callback?: (err: Error) => void): void;
+	export function fchmodSync(fd: number, mode: number): void;
+	export function fchmodSync(fd: number, mode: string): void;
+	export function lchmod(path: string, mode: string, callback?: (err: Error) => void): void;
+	export function lchmod(path: string, mode: number, callback?: (err: Error) => 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: Error, stats: Stats) => void): void;
+	export function lstat(path: string, callback?: (err: Error, stats: Stats) => void): void;
+	export function fstat(fd: number, callback?: (err: Error, stats: Stats) => void): 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: Error) => void): void;
+	export function linkSync(srcpath: string, dstpath: string): void;
+	export function symlink(srcpath: string, dstpath: string, type?: string, callback?: (err: Error) => void): void;
+	export function symlinkSync(srcpath: string, dstpath: string, type?: string): void;
+	export function readlink(path: string, callback?: (err: Error, linkString: string) => void): void;
+	export function realpath(path: string, callback?: (err: Error, resolvedPath: string) => void): void;
+	export function realpath(path: string, cache: string, callback: (err: Error, resolvedPath: string) => void): void;
+	export function realpathSync(path: string, cache?: boolean): string;
+	export function unlink(path: string, callback?: (err: Error) => void): void;
+	export function unlinkSync(path: string): void;
+	export function rmdir(path: string, callback?: (err: Error) => void): void;
+	export function rmdirSync(path: string): void;
+	export function mkdir(path: string, mode?: number, callback?: (err: Error) => void): void;
+	export function mkdir(path: string, mode?: string, callback?: (err: Error) => 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: Error, files: string[]) => void ): void;
+	export function readdirSync(path: string): string[];
+	export function close(fd: number, callback?: (err: Error) => void): void;
+	export function closeSync(fd: number): void;
+	export function open(path: string, flags: string, mode?: string, callback?: (err: Error, fs: number) => void): void;
+	export function openSync(path: string, flags: string, mode?: string): number;
+	export function utimes(path: string, atime: number, mtime: number, callback?: (err: Error) => void): void;
+	export function utimesSync(path: string, atime: number, mtime: number): void;
+	export function futimes(fd: number, atime: number, mtime: number, callback?: (err: Error) => void): void;
+	export function futimesSync(fd: number, atime: number, mtime: number): void;
+	export function fsync(fd: number, callback?: (err: Error) => void): void;
+	export function fsyncSync(fd: number): void;
+	export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, written: number, buffer: NodeBuffer) => void): void;
+	export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+	export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, bytesRead: number, buffer: NodeBuffer) => void ): void;
+	export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
+	export function readFile(filename: string, encoding: string, callback: (err: Error, data: string) => void ): void;
+	export function readFile(filename: string, options: OpenOptions, callback: (err: Error, data: string) => void ): void;
+	export function readFile(filename: string, callback: (err: Error, data: NodeBuffer) => void ): void;
+	export function readFileSync(filename: string): NodeBuffer;
+	export function readFileSync(filename: string, encoding: string): string;
+	export function readFileSync(filename: string, options: OpenOptions): string;
+	export function writeFile(filename: string, data: any, encoding?: string, callback?: (err: Error) => void): void;
+	export function writeFile(filename: string, data: any, options?: OpenOptions, callback?: (err: Error) => void): void;
+	export function writeFileSync(filename: string, data: any, encoding?: string): void;
+	export function writeFileSync(filename: string, data: any, option?: OpenOptions): void;
+	export function appendFile(filename: string, data: any, encoding?: string, callback?: (err: Error) => void): void;
+	export function appendFile(filename: string, data: any,option?: OpenOptions, callback?: (err: Error) => void): void;
+	export function appendFileSync(filename: string, data: any, encoding?: string): void;
+	export function appendFileSync(filename: string, data: any, option?: OpenOptions): void;
+	export function watchFile(filename: string, listener: { curr: Stats; prev: Stats; }): void;
+	export function watchFile(filename: string, options: { persistent?: boolean; interval?: number; }, listener: { curr: Stats; prev: Stats; }): void;
+	export function unwatchFile(filename: string, listener?: Stats): void;
+	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 interface OpenOptions {
+		encoding?: string;
+		flag?: string;
+	}
+
+	export interface ReadStreamOptions {
+		flags?: string;
+		encoding?: string;
+		fd?: number;
+		mode?: number;
+		bufferSize?: number;
+	}
+	export interface WriteStreamOptions {
+		flags?: string;
+		encoding?: string;
+		string?: string;
+	}
+	export function createReadStream(path: string, options?: ReadStreamOptions): ReadStream;
+	export function createWriteStream(path: string, options?: WriteStreamOptions): WriteStream;
+}

gently/gently-tests.ts

@@ -0,0 +1,14 @@
+/// <reference path="gently.d.ts" />
+
+import Gently = require('gently');
+
+var g = new Gently();
+
+g.expect(null, '', () => {
+	// ..
+})();
+g.expect(null, '', 0, () => {
+	// ..
+})();
+
+g.restore(null, '');

gently/gently.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for gently
+// Project: https://www.npmjs.org/package/gently
+// Definitions by: bonnici <https://github.com/bonnici>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/gently.d.ts
+
+declare module "gently" {
+	export = Gently;
+
+	class Gently {
+		constructor();
+		hijacked: any[];
+
+		expect(obj: any, method: string, stubFn?: (...args: any[]) => any): (...args: any[]) => any;
+		expect(obj: any, method: string, count: number, stubFn: (...args: any[]) => any): (...args: any[]) => any;
+
+		restore(obj: any, method: string): void;
+
+		hijack(realRequire: (id: string) => any): (id: string) => any;
+
+		stub(location: string, exportsName?: string): any;
+
+		verify(msg?: string): void;
+	}
+}

graceful-fs/graceful-fs-tests.ts

@@ -3,6 +3,6 @@
 import fs = require('graceful-fs');
 
 var str: string;
-var buf: NodeBuffer;
+var buf: Buffer;
 
 fs.renameSync(str, str);

gruntjs/gruntjs.d.ts

@@ -336,7 +336,7 @@ declare module grunt {
              * whose return value will be used as the destination file's contents. If
              * this function returns `false`, the file copy will be aborted.
              */
-            process?: (buffer: NodeBuffer) => boolean
+            process?: (buffer: Buffer) => boolean
         }
 
         /**
@@ -370,21 +370,21 @@ declare module grunt {
              * Returns a string, unless options.encoding is null in which case it returns a Buffer.
              */
             read(filepath: string): string
-            read(filepath: string, options: IFileEncodedOption): NodeBuffer
+            read(filepath: string, options: IFileEncodedOption): Buffer
 
             /**
              * Read a file's contents, parsing the data as JSON and returning the result.
              * @see FileModule.read for a list of supported options.
              */
             readJSON(filepath: string): any
-            readJSON(filepath: string, options: IFileEncodedOption): NodeBuffer
+            readJSON(filepath: string, options: IFileEncodedOption): Buffer
 
             /**
              * Read a file's contents, parsing the data as YAML and returning the result.
              * @see FileModule.read for a list of supported options.
              */
             readYAML(filepath: string): any
-            readYAML(filepath: string, options: IFileEncodedOption): NodeBuffer
+            readYAML(filepath: string, options: IFileEncodedOption): Buffer
 
             /**
              * Write the specified contents to a file, creating intermediate directories if necessary.
@@ -394,7 +394,7 @@ declare module grunt {
              * @param options If an encoding is not specified, default to grunt.file.defaultEncoding.
              */
             write(filepath: string, contents: string, options?: IFileEncodedOption): void
-            write(filepath: string, contents: NodeBuffer): void
+            write(filepath: string, contents: Buffer): void
 
             /**
              * Copy a source file to a destination path, creating intermediate directories if necessary.
@@ -1293,3 +1293,9 @@ interface IGrunt extends grunt.IConfigComponents, grunt.fail.FailModule, grunt.I
      */
     version: string
 }
+
+// NodeJS Support
+declare module 'grunt' {
+    var grunt: IGrunt;
+    export = grunt;
+}

handlebars/handlebars.d.ts

@@ -4,22 +4,45 @@
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 
+// Use either HandlebarsStatic or HandlebarsRuntimeStatic
 declare var Handlebars: HandlebarsStatic;
+//declare var Handlebars: HandlebarsRuntimeStatic;
 
-interface HandlebarsStatic {
+/**
+* Implement this interface on your MVW/MVVM/MVC views such as Backbone.View
+**/
+interface HandlebarsTemplatable {
+    template: HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsTemplateDelegate {
+    (context: any, options?: any): string;
+}
+
+interface HandlebarsCommon {
     registerHelper(name: string, fn: Function, inverse?: boolean): void;
     registerPartial(name: string, str: any): void;
     K(): void;
     createFrame(object: any): any;
+
     Exception(message: string): void;
     SafeString: typeof SafeString;
-    parse(input: string): boolean;
+
     logger: Logger;
     log(level: number, obj: any): void;
-    compile(input: any, options?: any): (context?: any, options?: any) => string;
     Logger: typeof Logger;
 }
 
+interface HandlebarsStatic extends HandlebarsCommon {
+    parse(input: string): boolean;
+    compile(input: any, options?: any): HandlebarsTemplateDelegate;
+}
+
+interface HandlebarsRuntimeStatic extends HandlebarsCommon {
+    // Handlebars.templates is the default template namespace in precompiler.
+    templates: { (s: string): HandlebarsTemplateDelegate }[];
+}
+
 declare class SafeString {
     constructor(str: string);
     static toString(): string;

highland/highland-tests.ts

@@ -22,9 +22,9 @@ var strArr: string[];
 var numArr: string[];
 var funcArr: Function[];
 
-var readable: ReadableStream;
-var writable: WritableStream;
-var emitter: NodeEventEmitter;
+var readable: NodeJS.ReadableStream;
+var writable: NodeJS.WritableStream;
+var emitter: NodeJS.EventEmitter;
 
 // - - - - - - - - - - - - - - - - -
 

highland/highland.d.ts

@@ -62,8 +62,8 @@ interface HighlandStatic {
 	<R>(xs: (push: (err: Error, x?: R) => void, next: () => void) => void): Highland.Stream<R>;
 
 	<R>(xs: Highland.Stream<R>): Highland.Stream<R>;
-	<R>(xs: ReadableStream): Highland.Stream<R>;
-	<R>(xs: NodeEventEmitter): Highland.Stream<R>;
+	<R>(xs: NodeJS.ReadableStream): Highland.Stream<R>;
+	<R>(xs: NodeJS.EventEmitter): Highland.Stream<R>;
 
 	// moar (promise for everything?)
 	<R>(xs: Highland.Thenable<Highland.Stream<R>>): Highland.Stream<R>;
@@ -365,7 +365,7 @@ declare module Highland {
 	/**
 	 * Actual Stream constructor wrapped the the main exported function
 	 */
-	interface Stream<R> extends NodeEventEmitter {
+	interface Stream<R> extends NodeJS.EventEmitter {
 
 		/**
 		 * Pauses the stream. All Highland Streams start in the paused state.
@@ -419,8 +419,8 @@ declare module Highland {
 		 * @api public
 		 */
 		pipe<U>(dest: Stream<U>): Stream<U>;
-		pipe<U>(dest: ReadWriteStream): Stream<U>;
-		pipe(dest: WritableStream): void;
+		pipe<U>(dest: NodeJS.ReadWriteStream): Stream<U>;
+		pipe(dest: NodeJS.WritableStream): void;
 
 		/**
 		 * Destroys a stream by unlinking it from any consumers and sources. This will

imagemagick/imagemagick-tests.ts

@@ -0,0 +1,27 @@
+/// <reference path="imagemagick.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import imagemagick = require('imagemagick');
+import child_process = require('child_process');
+
+var str: string = null;
+var num: number = 0;
+var cp: child_process.ChildProcess;
+
+cp = imagemagick.identify(str, (err: Error, res: imagemagick.Features) => {
+	str = res.format;
+	num = res.width;
+	num = res.height;
+	num = res.depth;
+});
+
+cp = imagemagick.convert(str, num, (err: Error, res: any) => {
+
+});
+
+cp = imagemagick.resize({
+	width: num,
+	height: num
+}, (err: Error, res: any) => {
+
+});

imagemagick/imagemagick.d.ts

@@ -0,0 +1,59 @@
+// Type definitions for imagemagick
+// Project: http://github.com/rsms/node-imagemagick
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/imagemagick.d.ts
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "imagemagick" {
+	import child_process = require("child_process");
+
+	export function identify(path: string, callback: (err: Error, features: Features) => void): child_process.ChildProcess;
+	export function identify(path: any[], callback: (err: Error, result: string) => void): child_process.ChildProcess;
+	export module identify {
+		export var path: string;
+	}
+	export function readMetadata(path: string, callback: (err: Error, result: any) => void): child_process.ChildProcess;
+
+	export function convert(args: any, callback: (err: Error, result: any) => void): child_process.ChildProcess;
+	export function convert(args: any, timeout: number, callback: (err: Error, result: any) => void): child_process.ChildProcess;
+	export module convert {
+		export var path: string;
+	}
+
+	export function resize(options: Options, callback: (err: Error, result: any) => void): child_process.ChildProcess;
+	export function crop(options: Options, callback: (err: Error, result: any) => void): child_process.ChildProcess;
+	export function resizeArgs(options: Options): ResizeArgs;
+
+	export interface Features {
+		format?: string;
+		width?: number;
+		height?: number;
+		depth?: number;
+	}
+
+	export interface Options {
+		srcPath?: string; //: null,
+		srcData?: string; //: null,
+		srcFormat?: string; //: null,
+		dstPath?: string; //: null,
+		quality?: number; //: 0.8,
+		format?: string; //: 'jpg',
+		progressive?: boolean; //: false,
+		colorspace?: any; //: null,
+		width?: number; //: 0,
+		height?: number; //: 0,
+		strip?: boolean; //: true,
+		filter?: string; //: 'Lagrange',
+		sharpening?: number; //: 0.2,
+		customArgs?: any[]; //: [],
+		timeout?: number; //: 0
+	}
+
+	export interface ResizeArgs {
+		opt: Options;
+		args: string[];
+	}
+}

jake/jake.d.ts

@@ -133,7 +133,7 @@ declare module jake{
 	 * @event stderr When the stderr for the child-process recieves data. This streams the stderr data. Passes one arg, the chunk of data.
 	 * @event error When a shell-command
 	 */
-	export interface Exec extends NodeEventEmitter {
+	export interface Exec extends NodeJS.EventEmitter {
 		append(cmd:string): void;
 		run(): void;
 	}
@@ -187,7 +187,7 @@ declare module jake{
 	 *
 	 * @event complete
 	 */
-	export class Task implements NodeEventEmitter {
+	export class Task implements NodeJS.EventEmitter {
 		/**
 		 * @name name The name of the Task
 		 * @param prereqs Prerequisites to be run before this task
@@ -206,11 +206,11 @@ declare module jake{
 		 */
 		reenable(): void;
 
-		addListener(event: string, listener: Function): NodeEventEmitter;
-        on(event: string, listener: Function): NodeEventEmitter;
-        once(event: string, listener: Function): NodeEventEmitter;
-        removeListener(event: string, listener: Function): NodeEventEmitter;
-        removeAllListeners(event?: string): NodeEventEmitter;
+		addListener(event: string, listener: Function): NodeJS.EventEmitter;
+        on(event: string, listener: Function): NodeJS.EventEmitter;
+        once(event: string, listener: Function): NodeJS.EventEmitter;
+        removeListener(event: string, listener: Function): NodeJS.EventEmitter;
+        removeAllListeners(event?: string): NodeJS.EventEmitter;
         setMaxListeners(n: number): void;
         listeners(event: string): Function[];
         emit(event: string, ...args: any[]): boolean;
@@ -381,11 +381,11 @@ declare module jake{
 		constructor(name:string, definition?:()=>void);
 	}
 
-	export function addListener(event: string, listener: Function): NodeEventEmitter;
-	export function on(event: string, listener: Function): NodeEventEmitter;
-	export function once(event: string, listener: Function): NodeEventEmitter;
-	export function removeListener(event: string, listener: Function): NodeEventEmitter;
-	export function removeAllListener(event: string): NodeEventEmitter;
+	export function addListener(event: string, listener: Function): NodeJS.EventEmitter;
+	export function on(event: string, listener: Function): NodeJS.EventEmitter;
+	export function once(event: string, listener: Function): NodeJS.EventEmitter;
+	export function removeListener(event: string, listener: Function): NodeJS.EventEmitter;
+	export function removeAllListener(event: string): NodeJS.EventEmitter;
 	export function setMaxListeners(n: number): void;
 	export function listeners(event: string): Function[];
 	export function emit(event: string, ...args: any[]): boolean;

jquery.finger/jquery.finger-tests.ts

@@ -0,0 +1,37 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="jquery.finger.d.ts"/>
+
+$.Finger.doubleTapInterval = 400;
+$.Finger.flickDuration = 250;
+$.Finger.pressDuration = 100;
+$.Finger.motionThreshhold = 10;
+$.Finger.preventDefault = true;
+var fingerEventObject: JQueryFingerEventObject;
+fingerEventObject.x = 1;
+fingerEventObject.y = 2;
+fingerEventObject.dx = 3;
+fingerEventObject.dy = 4;
+fingerEventObject.adx = 3;
+fingerEventObject.ady = 4;
+fingerEventObject.orientation = 'horizontal';
+fingerEventObject.direction = 1;
+$('body').on('drag', e => {
+    if ('vertical' == e.orientation) return;
+    e.preventDefault();
+});
+
+$('body').on('drag', '.drag', e => {
+    if ('vertical' == e.orientation) return;
+    e.preventDefault();
+});
+
+$('#menu').on('flick', function (e) {
+    if ('horizontal' == e.orientation) {
+        if (1 == e.direction) {
+            $(this).addClass('is-opened');
+        }
+        else {
+            $(this).removeClass('is-opened');
+        }
+    }
+});

jquery.finger/jquery.finger.d.ts

@@ -0,0 +1,109 @@
+// Type definitions for jquery.finger.js
+// Project: http://ngryman.sh/jquery.finger/
+// Definitions by: Max Ackley <https://github.com/maxackley/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare module JQueryFinger {
+    export interface JQueryFingerOptions {
+        /**
+          * The time the user must hold in order to fire a press event. If this
+          * time is not reached, a tap event will be fired instead.
+          *     Default: 300(ms).
+          */
+        pressDuration: number;
+
+        /**
+          * The maximum time between two tap events to fire a doubletap event.
+          * If this time is reached, two distinct tap events will be fired instead.
+          *     Default: 300(ms).
+          */
+        doubleTapInterval: number;
+
+        /**
+          * The maximum time the user will have to swipe in order to fire a flick
+          * event. If this time is reached, only drag events will continue to be 
+          * fired. 
+          *     Default: 150(ms).
+          */
+        flickDuration: number;
+
+        /**
+          * The number of pixels the user will have to move in order to fire motion
+          * events (drag or flick). If this time is not reached, no motion will
+          * be handled and tap, doubletap or press event will be fired.
+          *     Default: 5(px).
+          */
+        motionThreshhold: number;
+
+        /**
+          * Globally prevents every native default behavior.
+          *     Default: undefined.
+          */
+        preventDefault: boolean;
+    }
+}
+
+interface JQueryFingerEventObject extends JQueryEventObject {
+    /**
+      * The x page coordinate.
+      */
+    x: number;
+    
+    /**
+      * The y page coordinate.
+      */
+    y: number;
+    
+    /**
+      * The x delta since the last event.
+      */
+    dx: number;
+    
+    /**
+      * The y delta since the last event.
+      */
+    dy: number;
+    
+    /**
+      * The absolute x delta since the last event.
+      */
+    adx: number;
+    
+    /**
+      * The absolute y delta since the last event.
+      */
+    ady: number;
+    
+    /**
+      * The orientation of the motion. Adjusted by $.Finger.motionThreshhold.
+      * Value is 'horizontal' or 'vertical'.
+      */
+    orientation: string;
+    
+    /**
+      * The direction of the motion. Value is 1 if the motion is 'positive'
+      * (left-to-right or top-to-bottom) or -1 if 'negative'(right-to-left or
+      * bottom-to-top).
+      */
+    direction: number;
+}
+
+interface JQuery {
+    on(events: 'tap', handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'doubletap', handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'press', handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'drag', handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'flick', handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+
+    on(events: 'tap', data: any, handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'doubletap', data: any, handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'press', data: any, handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'drag', data: any, handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'flick', data: any, handler: (eventObject: JQueryFingerEventObject, ...args: any[]) => any): JQuery;
+}
+
+interface JQueryStatic {
+    Finger: JQueryFinger.JQueryFingerOptions;
+}

jqueryui/jqueryui-tests.ts

@@ -1362,6 +1362,33 @@ function test_datepicker() {
         $set = $(".selector").datepicker("option", "defaultDate", new Date());
         $set = $(".selector").datepicker("option", "defaultDate", "+1m +7d");
     }
+
+    function duration() {
+        $(".selector").datepicker({ duration: "slow" });
+
+        var duration: string = $(".selector").datepicker("option", "duration");
+
+        // setter
+        var $set: JQuery = $(".selector").datepicker("option", "duration", "slow");
+    }
+
+    function firstDay() {
+        $(".selector").datepicker({ firstDay: 1 });
+
+        var firstDay: number = $(".selector").datepicker("option", "firstDay");
+
+        // setter
+        var $set: JQuery = $(".selector").datepicker("option", "firstDay", 1);
+    }
+
+    function gotoCurrent() {
+        $(".selector").datepicker({ gotoCurrent: true });
+
+        var gotoCurrent: boolean = $(".selector").datepicker("option", "gotoCurrent");
+
+        // setter
+        var $set: JQuery = $(".selector").datepicker("option", "gotoCurrent", true);
+    }
 }
 
 

jqueryui/jqueryui.d.ts

@@ -1278,14 +1278,14 @@ interface JQuery {
      * Get the calculateWeek option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'calculateWeek'
      */
     datepicker(methodName: 'option', optionName: 'calculateWeek'): (date: Date) => string;
     /**
      * Set the calculateWeek option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'calculateWeek'
      * @param calculateWeekValue A function to calculate the week of the year for a given date. The default implementation uses the ISO 8601 definition: weeks start on a Monday; the first week of the year contains the first Thursday of the year.
      */
     datepicker(methodName: 'option', optionName: 'calculateWeek', calculateWeekValue: (date: Date) => string): JQuery;
@@ -1294,14 +1294,14 @@ interface JQuery {
      * Get the changeMonth option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'changeMonth'
      */
     datepicker(methodName: 'option', optionName: 'changeMonth'): boolean;
     /**
      * Set the changeMonth option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'changeMonth'
      * @param changeMonthValue Whether the month should be rendered as a dropdown instead of text.
      */
     datepicker(methodName: 'option', optionName: 'changeMonth', changeMonthValue: boolean): JQuery;
@@ -1310,14 +1310,14 @@ interface JQuery {
      * Get the changeYear option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'changeYear'
      */
     datepicker(methodName: 'option', optionName: 'changeYear'): boolean;
     /**
      * Set the changeYear option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'changeYear'
      * @param changeYearValue Whether the year should be rendered as a dropdown instead of text. Use the yearRange option to control which years are made available for selection.
      */
     datepicker(methodName: 'option', optionName: 'changeYear', changeYearValue: boolean): JQuery;
@@ -1326,14 +1326,14 @@ interface JQuery {
      * Get the closeText option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'closeText'
      */
     datepicker(methodName: 'option', optionName: 'closeText'): string;
     /**
      * Set the closeText option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'closeText'
      * @param closeTextValue The text to display for the close link. Use the showButtonPanel option to display this button.
      */
     datepicker(methodName: 'option', optionName: 'closeText', closeTextValue: string): JQuery;
@@ -1342,14 +1342,14 @@ interface JQuery {
      * Get the constrainInput option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'constrainInput'
      */
     datepicker(methodName: 'option', optionName: 'constrainInput'): boolean;
     /**
      * Set the constrainInput option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'constrainInput'
      * @param constrainInputValue When true, entry in the input field is constrained to those characters allowed by the current dateFormat option.
      */
     datepicker(methodName: 'option', optionName: 'constrainInput', constrainInputValue: boolean): JQuery;
@@ -1358,14 +1358,14 @@ interface JQuery {
      * Get the currentText option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'currentText'
      */
     datepicker(methodName: 'option', optionName: 'currentText'): string;
     /**
      * Set the currentText option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'currentText'
      * @param currentTextValue The text to display for the current day link. Use the showButtonPanel option to display this button.
      */
     datepicker(methodName: 'option', optionName: 'currentText', currentTextValue: string): JQuery;
@@ -1374,14 +1374,14 @@ interface JQuery {
      * Get the dateFormat option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dateFormat'
      */
     datepicker(methodName: 'option', optionName: 'dateFormat'): string;
     /**
      * Set the dateFormat option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dateFormat'
      * @param dateFormatValue The format for parsed and displayed dates. For a full list of the possible formats see the formatDate function.
      */
     datepicker(methodName: 'option', optionName: 'dateFormat', dateFormatValue: string): JQuery;
@@ -1390,14 +1390,14 @@ interface JQuery {
      * Get the dayNames option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNames'
      */
     datepicker(methodName: 'option', optionName: 'dayNames'): string[];
     /**
      * Set the dayNames option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNames'
      * @param dayNamesValue The list of long day names, starting from Sunday, for use as requested via the dateFormat option.
      */
     datepicker(methodName: 'option', optionName: 'dayNames', dayNamesValue: string[]): JQuery;
@@ -1406,14 +1406,14 @@ interface JQuery {
      * Get the dayNamesMin option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNamesMin'
      */
     datepicker(methodName: 'option', optionName: 'dayNamesMin'): string[];
     /**
      * Set the dayNamesMin option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNamesMin'
      * @param dayNamesMinValue The list of minimised day names, starting from Sunday, for use as column headers within the datepicker.
      */
     datepicker(methodName: 'option', optionName: 'dayNamesMin', dayNamesMinValue: string[]): JQuery;
@@ -1422,14 +1422,14 @@ interface JQuery {
      * Get the dayNamesShort option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNamesShort'
      */
     datepicker(methodName: 'option', optionName: 'dayNamesShort'): string[];
     /**
      * Set the dayNamesShort option, after initialization
      *
      * @param methodName 'option'
-     * @param optionName 'buttonText'
+     * @param optionName 'dayNamesShort'
      * @param dayNamesShortValue The list of abbreviated day names, starting from Sunday, for use as requested via the dateFormat option.
      */
     datepicker(methodName: 'option', optionName: 'dayNamesShort', dayNamesShortValue: string[]): JQuery;
@@ -1466,6 +1466,54 @@ interface JQuery {
      */
     datepicker(methodName: 'option', optionName: 'defaultDate', defaultDateValue: string): JQuery;
 
+    /**
+     * Get the duration option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'duration'
+     */
+    datepicker(methodName: 'option', optionName: 'duration'): string;
+    /**
+     * Set the duration option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'duration'
+     * @param durationValue Control the speed at which the datepicker appears, it may be a time in milliseconds or a string representing one of the three predefined speeds ("slow", "normal", "fast").
+     */
+    datepicker(methodName: 'option', optionName: 'duration', durationValue: string): JQuery;
+
+    /**
+     * Get the firstDay option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'firstDay'
+     */
+    datepicker(methodName: 'option', optionName: 'firstDay'): number;
+    /**
+     * Set the firstDay option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'firstDay'
+     * @param firstDayValue Set the first day of the week: Sunday is 0, Monday is 1, etc.
+     */
+    datepicker(methodName: 'option', optionName: 'firstDay', firstDayValue: number): JQuery;
+
+    /**
+     * Get the gotoCurrent option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'gotoCurrent'
+     */
+    datepicker(methodName: 'option', optionName: 'gotoCurrent'): boolean;
+    /**
+     * Set the gotoCurrent option, after initialization
+     *
+     * @param methodName 'option'
+     * @param optionName 'gotoCurrent'
+     * @param gotoCurrentValue When true, the current day link moves to the currently selected date instead of today.
+     */
+    datepicker(methodName: 'option', optionName: 'gotoCurrent', gotoCurrentValue: boolean): JQuery;
+
     /**
      * Gets the value currently associated with the specified optionName.
      *

js-url/js-url-test.ts

@@ -0,0 +1,9 @@
+/// <reference path="js-url.d.ts" />
+
+url();
+
+url('domain');
+url(1);
+
+url('domain', 'test.www.example.com/path/here');
+url(-1, 'test.www.example.com/path/here');

js-url/js-url.d.ts

@@ -0,0 +1,14 @@
+// Type definitions for url() v1.8.6
+// Project: https://github.com/websanova/js-url
+// Definitions by: MIZUNE Pine <https://github.com/pine613>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface UrlStatic {
+  (): string;
+  (pattern: string): string;
+  (pattern: number): string;
+  (pattern: string, url: string): string;
+  (pattern: number, url: string): string;
+}
+
+declare var url: UrlStatic;

memory-cache/memory-cache-tests.ts

@@ -0,0 +1,24 @@
+/// <reference path="memory-cache.d.ts" />
+
+import memoryCache = require('memory-cache');
+
+var key: any;
+var value: any;
+var bool: boolean;
+var num: number;
+
+memoryCache.put(key, value);
+memoryCache.put(key, value, num);
+memoryCache.put(key, value, num, (key) => {
+
+});
+value = memoryCache.get(key);
+memoryCache.del(key);
+memoryCache.clear();
+
+num = memoryCache.size();
+num = memoryCache.memsize();
+
+memoryCache.debug(bool);
+num = memoryCache.hits();
+num = memoryCache.misses();

memory-cache/memory-cache.d.ts

@@ -0,0 +1,20 @@
+// Type definitions for memory-cache
+// Project: http://github.com/ptarjan/node-cache
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/memory-cache.d.ts
+
+declare module "memory-cache" {
+	export function put(key: any, value: any, time?: number, timeoutCallback?: (key: any) => void): void;
+	export function get(key: any): any;
+	export function del(key: any): void;
+	export function clear(): void;
+
+	export function size(): number;
+	export function memsize(): number;
+
+	export function debug(bool: boolean): void;
+	export function hits(): number;
+	export function misses(): number;
+}

mime/mime-tests.ts

@@ -0,0 +1,13 @@
+/// <reference path="mime.d.ts" />
+
+import mime = require('mime');
+
+var str: string;
+var obj: Object;
+
+str = mime.lookup(str);
+str = mime.extension(str);
+mime.load(str);
+mime.define(obj);
+
+str = mime.charsets.lookup(str);

mime/mime.d.ts

@@ -0,0 +1,19 @@
+// 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;
+}

msnodesql/msnodesql.d.ts

@@ -7,6 +7,8 @@
 ///<reference path='../node/node.d.ts' />
 
 declare module "msnodesql" {
+    import events = require('events');
+
     export function open(connectionString: string, callback?: OpenCallback): Connection;
 
     export function query(connectionString: string, query: string, callback?: QueryCallback): StreamEvents;
@@ -55,5 +57,5 @@ declare module "msnodesql" {
         close(immediately: boolean, callback?: ErrorCallback);
     }
 
-    interface StreamEvents extends NodeEventEmitter { }
+    interface StreamEvents extends events.EventEmitter {}
 }

mu2/mu2-tests.ts

@@ -0,0 +1,32 @@
+/// <reference path="mu2.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import mu2 = require('mu2');
+import stream = require('stream');
+
+var str: string;
+var value: any;
+var read: NodeJS.ReadableStream;
+var parsed: mu2.IParsed;
+
+str = mu2.root;
+
+read = mu2.compileAndRender(str, value);
+
+mu2.compile(str, (err: Error, parsed: mu2.IParsed) => {
+
+});
+mu2.compileText(str, str, (err: Error, parsed: mu2.IParsed) => {
+
+});
+parsed = mu2.compileText(str, str);
+parsed = mu2.compileText(str);
+
+read = mu2.render(str, value);
+read = mu2.render(parsed, value);
+
+read = mu2.renderText(str, value);
+read = mu2.renderText(str, value, value);
+
+mu2.clearCache();
+mu2.clearCache(str);

mu2/mu2.d.ts

@@ -0,0 +1,29 @@
+// Type definitions for mu2
+// Project: http://github.com/raycmorgan/mu
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/mu2.d.ts
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "mu2" {
+	export var root: string;
+
+	export function compileAndRender(templateName: string, view: any): NodeJS.ReadableStream;
+
+	export function compile(filename: string, callback: (err: Error, parsed: IParsed) => void): void;
+
+	export function compileText(name: string, template: string, callback: (err: Error, parsed: IParsed) => void): void;
+	export function compileText(name: string, template: string): IParsed;
+	export function compileText(template: string): IParsed;
+
+	export function render(filenameOrParsed: string, view: any): NodeJS.ReadableStream;
+	export function render(filenameOrParsed: IParsed, view: any): NodeJS.ReadableStream;
+
+	export function renderText(template: string, view: any, partials?: any): NodeJS.ReadableStream;
+
+	export function clearCache(templateName?: string): void;
+
+	export interface IParsed { }
+}

nconf/nconf-tests.ts

@@ -0,0 +1,101 @@
+/// <reference path="nconf.d.ts" />
+
+import nconf = require('nconf');
+
+var value: any;
+var num: number;
+var bool: boolean;
+var valueArr: any[];
+var str: string;
+var strArr: string[];
+var p: nconf.Provider;
+var opts: nconf.IOptions;
+var fopts: nconf.IFileOptions;
+var store: nconf.IStore;
+var callback: (err: Error) => void;
+
+value = nconf.clear(str, callback);
+value = nconf.get (str, callback);
+value = nconf.merge(str, value, callback);
+value = nconf.set (str, value, callback);
+value = nconf.reset(callback);
+
+value = nconf.load(callback);
+nconf.mergeSources(value);
+value = nconf.loadSources();
+value = nconf.save(value, callback);
+
+p = nconf.add(str);
+p = nconf.add(str, opts);;
+
+p = nconf.argv();
+p = nconf.argv(opts);
+
+p = nconf.env();
+p = nconf.env(opts);
+
+p = nconf.file(str);
+p = nconf.file(str, fopts);
+p = nconf.file(fopts);
+
+p = nconf.use(str);
+p = nconf.use(str, opts);
+
+p = nconf.defaults();
+p = nconf.defaults(opts);
+
+nconf.init();
+nconf.init(opts);
+
+p = nconf.overrides();
+p = nconf.overrides(opts);
+nconf.remove(str);
+store = nconf.create(str, opts);
+
+str = nconf.key(value, value);
+valueArr = nconf.path(value);
+nconf.loadFiles(value, callback);
+nconf.loadFilesSync(value, callback);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - -
+
+str = store.type;
+value = store.get(str);
+bool = store.set(str, value);
+bool = store.clear(str);
+bool = store.merge(str, value);
+bool = store.reset(callback);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - -
+
+p = new nconf.Provider(opts);
+value = p.stores;
+valueArr = p.sources;
+
+value = p.clear(str, callback);
+value = p.get(str, callback);
+value = p.merge(str,value,callback);
+value = p.set(str,value,callback);
+value = p.reset(callback);
+
+value = p.load(callback);
+p.mergeSources(value);
+value = p.loadSources();
+value = p.save(value, callback);
+
+p = p.add(str);
+p = p.add(str, opts);
+p = p.argv();
+p = p.argv(opts);
+p = p.env();
+p = p.env(opts);
+p = p.file(str);
+p = p.file(str, fopts);
+p = p.file(fopts);
+p = p.use(str, opts);
+
+p = p.defaults(opts);
+p.init(opts);
+p = p.overrides(opts);
+p.remove(str);
+store = p.create(str, opts);

nconf/nconf.d.ts

@@ -0,0 +1,100 @@
+// Type definitions for nconf
+// Project: https://github.com/flatiron/nconf
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/nconf.d.ts
+
+declare module "nconf" {
+	export var version: number;
+	export var stores: any;
+	export var sources: any[];
+
+	export function clear(key: string, callback?: ICallbackFunction): any;
+	export function get (key: string, callback?: ICallbackFunction): any;
+	export function merge(key: string, value: any, callback?: ICallbackFunction): any;
+	export function set (key: string, value: any, callback?: ICallbackFunction): any;
+	export function reset(callback?: ICallbackFunction): any;
+
+	export function load(callback?: ICallbackFunction): any;
+	export function mergeSources(data: any): void;
+	export function loadSources(): any;
+	export function save(value: any, callback?: ICallbackFunction): any;
+
+	export function add(name: string, options?: IOptions): Provider;
+	export function argv(options?: IOptions): Provider;
+	export function env(options?: IOptions): Provider;
+	export function file(name: string, options?: IFileOptions): Provider;
+	export function file(options: IFileOptions): Provider;
+	export function use(name: string, options?: IOptions): Provider;
+	export function defaults(options?: IOptions): Provider;
+	export function init(options?: IOptions): void;
+	export function overrides(options?: IOptions): Provider;
+	export function remove(name: string): void;
+	export function create(name: string, options: IOptions): IStore;
+
+	export function key(...values: any[]): string;
+	export function path(key: any): any[];
+	export function loadFiles(files: any, callback?: ICallbackFunction): void;
+	export function loadFilesSync(files: any, callback?: ICallbackFunction): void;
+
+	export enum formats {
+		json,
+		ini
+	}
+
+	export interface IOptions {
+		type?: string;
+	}
+
+	export interface IFileOptions extends IOptions {
+		file?: string;
+		dir?: string;
+		search?: boolean;
+		json_spacing?: number;
+	}
+
+	export interface ICallbackFunction {
+		(err: Error): void;
+	}
+
+	export class Provider {
+		constructor(options: IOptions);
+
+		stores: any;
+		sources: any[];
+
+		clear(key: string, callback?: ICallbackFunction): any;
+		get (key: string, callback?: ICallbackFunction): any;
+		merge(key: string, value: any, callback?: ICallbackFunction): any;
+		set (key: string, value: any, callback?: ICallbackFunction): any;
+		reset(callback?: ICallbackFunction): any;
+
+		load(callback?: ICallbackFunction): any;
+		mergeSources(data: any): void;
+		loadSources(): any;
+		save(value: any, callback?: ICallbackFunction): any;
+
+		add(name: string, options?: IOptions): Provider;
+		argv(options?: IOptions): Provider;
+		env(options?: IOptions): Provider;
+		file(name: string, options?: IFileOptions): Provider;
+		file(options: IFileOptions): Provider;
+		use(name: string, options?: IOptions): Provider;
+
+		defaults(options?: IOptions): Provider;
+		init(options?: IOptions): void;
+		overrides(options?: IOptions): Provider;
+		remove(name: string): void;
+		create(name: string, options: IOptions): IStore;
+	}
+
+	export interface IStore {
+		type: string;
+		get (key: string): any;
+		set (key: string, value: any): boolean;
+		clear(key: string): boolean;
+		merge(key: string, value: any): boolean;
+		reset(callback?: ICallbackFunction): boolean;
+	}
+}

noble/noble-tests.ts

@@ -0,0 +1,82 @@
+/// <reference path="noble.d.ts" />
+
+import noble = require("noble");
+
+function test_startScanning(): void {
+    "use strict";
+    noble.startScanning();
+    noble.startScanning(["0x180d"]);
+    noble.startScanning(["0x180d"], true);
+}
+test_startScanning();
+
+function test_stopScanning(): void {
+    "use strict";
+    noble.stopScanning();
+}
+test_stopScanning();
+
+noble.on("stateChange", (state: string): void => {});
+noble.on("scanStart", (): void => {});
+noble.on("scanStop", (): void => {});
+noble.on("discover", (peripheral: noble.Peripheral): void => {
+    peripheral.connect((error: string): void => {});
+    peripheral.disconnect((): void => {});
+});
+
+var peripheral: noble.Peripheral = new noble.Peripheral();
+peripheral.uuid = "12ad4e81";
+peripheral.advertisement = {
+    localName:        "device",
+    serviceData:      new Buffer(1),
+    txPowerLevel:     1,
+    manufacturerData: new Buffer(1),
+    serviceUuids:     ["0x180a", "0x180d"]
+};
+peripheral.connect((error: string): void => {});
+peripheral.disconnect((): void => {});
+peripheral.discoverServices(["180d"], (error: string, services: noble.Service[]): void => {});
+peripheral.discoverAllServicesAndCharacteristics((error: string, services: noble.Service[], characteristics: noble.Characteristic[]): void => {});
+peripheral.discoverSomeServicesAndCharacteristics(["180d"], ["2a38"], (error: string, services: noble.Service[], characteristics: noble.Characteristic[]): void => {});
+peripheral.readHandle(new Buffer(1), (error: string, data: NodeBuffer): void => {});
+peripheral.writeHandle(new Buffer(1), new Buffer(1), true, (error: string): void => {});
+peripheral.on("connect", (error: string): void => {});
+peripheral.on("disconnect", (error: string): void => {});
+peripheral.on("rssiUpdate", (rssi: number): void => {});
+peripheral.on("servicesDiscover", (services: noble.Service[]): void => {});
+
+var service: noble.Service = new noble.Service();
+service.uuid = "180a";
+service.name = "";
+service.type = "";
+service.includedServiceUuids = ["180d"];
+service.discoverIncludedServices(["180d"], (error: string, includedServiceUuids: string[]): void => {});
+service.discoverCharacteristics(["2a38"], (error: string, characteristics: noble.Characteristic[]): void => {});
+service.on("includedServicesDiscover", (includedServiceUuids: string[]): void => {});
+service.on("characteristicsDiscover", (characteristics: noble.Characteristic[]): void => {});
+
+var characteristic: noble.Characteristic = new noble.Characteristic();
+characteristic.uuid = "2a37";
+characteristic.name = "";
+characteristic.type = "";
+characteristic.properties = ["read", "notify"];
+characteristic.read((error: string, data: NodeBuffer): void => {});
+characteristic.write(new Buffer(1), true, (error: string): void => {});
+characteristic.broadcast(true, (error: string): void => {});
+characteristic.notify(true, (error: string): void => {});
+characteristic.discoverDescriptors((error: string, descriptors: noble.Descriptor[]): void => {});
+characteristic.on("read", (data: NodeBuffer, isNotification: boolean): void => {});
+characteristic.on("write", true, (error: string): void => {});
+characteristic.on("broadcast", (state: string): void => {});
+characteristic.on("notify", (state: string): void => {});
+characteristic.on("descriptorsDiscover", (descriptors: noble.Descriptor[]): void => {});
+
+var descriptor: noble.Descriptor = new noble.Descriptor();
+descriptor.uuid = "";
+descriptor.name = "";
+descriptor.type = "";
+descriptor.readValue((error: string, data: NodeBuffer): void => {});
+descriptor.writeValue(new Buffer(1), (error: string): void => {});
+descriptor.on("valueRead", (error: string, data: NodeBuffer): void => {});
+descriptor.on("valueWrite", (error: string): void => {});
+

noble/noble.d.ts

@@ -0,0 +1,106 @@
+// Type definitions for noble
+// Project: https://github.com/sandeepmistry/noble
+// Definitions by: Seon-Wook Park <https://github.com/swook>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "noble" {
+    import events = require("events");
+
+    export function startScanning(): void;
+    export function startScanning(serviceUUIDs: string[]): void;
+    export function startScanning(serviceUUIDs: string[], allowDuplicates: boolean): void;
+    export function stopScanning(): void;
+
+    export function on(event: string, listener: Function): events.EventEmitter;
+    export function on(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
+    export function on(event: "scanStart", listener: () => void): events.EventEmitter;
+    export function on(event: "scanStop", listener: () => void): events.EventEmitter;
+    export function on(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
+
+    export class Peripheral extends events.EventEmitter {
+        uuid:          string;
+        advertisement: Advertisement;
+        rssi:          number;
+        services:      string[];
+
+        connect(callback: (error: string) => void): void;
+        disconnect(callback: () => void): void;
+        discoverServices(serviceUUIDs: string[], listener: (error: string, services: Service[]) => void): void;
+        discoverAllServicesAndCharacteristics(callback: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
+        discoverSomeServicesAndCharacteristics(serviceUUIDs: string[], characteristicUUIDs: string[], callback: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
+
+        readHandle(handle: NodeBuffer, callback: (error: string, data: NodeBuffer) => void): void;
+        writeHandle(handle: NodeBuffer, data: NodeBuffer, withoutResponse: boolean, callback: (error: string) => void): void;
+        toString(): string;
+
+        on(event: string, listener: Function): events.EventEmitter;
+        on(event: "connect", listener: (error: string) => void): events.EventEmitter;
+        on(event: "disconnect", listener: (error: string) => void): events.EventEmitter;
+        on(event: "rssiUpdate", listener: (rssi: number) => void): events.EventEmitter;
+        on(event: "servicesDiscover", listener: (services: Service[]) => void): events.EventEmitter;
+    }
+
+    export interface Advertisement {
+        localName:        string;
+        serviceData:      NodeBuffer;
+        txPowerLevel:     number;
+        manufacturerData: NodeBuffer;
+        serviceUuids:     string[];
+    }
+
+    export class Service extends events.EventEmitter {
+        uuid:                 string;
+        name:                 string;
+        type:                 string;
+        includedServiceUuids: string[];
+        characteristics:      Characteristic[];
+
+        discoverIncludedServices(serviceUUIDs: string[], callback: (error: string, includedServiceUuids: string[]) => void): void;
+        discoverCharacteristics(characteristicUUIDs: string[], callback: (error: string, characteristics: Characteristic[]) => void): void;
+        toString(): string;
+
+        on(event: string, listener: Function): events.EventEmitter;
+        on(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): events.EventEmitter;
+        on(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): events.EventEmitter;
+    }
+
+    export class Characteristic extends events.EventEmitter {
+        uuid:        string;
+        name:        string;
+        type:        string;
+        properties:  string[];
+        descriptors: Descriptor[];
+
+        read(callback: (error: string, data: NodeBuffer) => void): void;
+        write(data: NodeBuffer, notify: boolean, callback: (error: string) => void): void;
+        broadcast(broadcast: boolean, callback: (error: string) => void): void;
+        notify(notify: boolean, callback: (error: string) => void): void;
+        discoverDescriptors(callback: (error: string, descriptors: Descriptor[]) => void): void;
+        toString(): string;
+
+        on(event: string, listener: Function): events.EventEmitter;
+        on(event: string, option: boolean, listener: Function): events.EventEmitter;
+        on(event: "read", listener: (data: NodeBuffer, isNotification: boolean) => void): events.EventEmitter;
+        on(event: "write", withoutResponse: boolean, listener: (error: string) => void): events.EventEmitter;
+        on(event: "broadcast", listener: (state: string) => void): events.EventEmitter;
+        on(event: "notify", listener: (state: string) => void): events.EventEmitter;
+        on(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): events.EventEmitter;
+    }
+
+    export class Descriptor extends events.EventEmitter {
+        uuid: string;
+        name: string;
+        type: string;
+
+        readValue(callback: (error: string, data: NodeBuffer) => void): void;
+        writeValue(data: NodeBuffer, callback: (error: string) => void): void;
+        toString(): string;
+
+        on(event: string, listener: Function): events.EventEmitter;
+        on(event: "valueRead", listener: (error: string, data: NodeBuffer) => void): events.EventEmitter;
+        on(event: "valueWrite", listener: (error: string) => void): events.EventEmitter;
+    }
+}
+

nock/nock-tests.ts

@@ -0,0 +1,60 @@
+/// <reference path="nock.d.ts" />
+
+import nock = require('nock');
+
+var inst: nock.Scope;
+var str: string;
+var bool: boolean;
+var data: string;
+var num: number;
+var value: any;
+var regex: RegExp;
+var options: nock.Options;
+var headers: Object;
+
+inst = inst.head(str);
+inst = inst.get(str);
+inst = inst.get(str, data);
+inst = inst.post(str);
+inst = inst.post(str, data);
+inst = inst.put(str);
+inst = inst.put(str, data);
+
+inst = inst.delete(str);
+inst = inst.delete(str, data);
+
+inst = inst.intercept(str, str);
+inst = inst.intercept(str, str, str);
+inst = inst.intercept(str, str, str, value);
+
+inst = inst.reply(num);
+inst = inst.reply(num, str);
+inst = inst.reply(num, str, headers);
+inst = inst.reply(num, (uri: string, body: string) => {
+	return str;
+});
+inst = inst.reply(num, (uri: string, body: string) => {
+	return str;
+}, headers);
+inst = inst.replyWithFile(num, str);
+
+inst = inst.defaultReplyHeaders(value);
+inst = inst.matchHeader(str, str);
+
+inst = inst.filteringPath(regex, str);
+inst = inst.filteringPath((path: string) => {
+	return str;
+});
+inst = inst.filteringRequestBody(regex, str);
+inst = inst.filteringRequestBody((path: string) => {
+	return str;
+});
+
+inst = inst.persist();
+inst = inst.log(() => {
+
+});
+
+inst.done();
+bool = inst.isDone();
+inst.restore();

nock/nock.d.ts

@@ -0,0 +1,54 @@
+// Type definitions for nock
+// Project: https://github.com/pgte/nock
+// Definitions by: bonnici <https://github.com/bonnici>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/nock.d.ts
+
+declare module "nock" {
+	export = nock;
+
+	function nock (host: string, options?: nock.Options): nock.Scope;
+
+	module nock {
+		export function cleanAll(): void;
+		export var recorder: Recorder;
+
+		export interface Scope {
+			get(path: string, data?: string): Scope;
+			post(path: string, data?: string): Scope;
+			put(path: string, data?: string): Scope;
+			head(path: string): Scope;
+			delete(path: string, data?: string): Scope;
+			intercept(path: string, verb: string, body?: string, options?: any): Scope;
+
+			reply(responseCode: number, body?: string, headers?: Object): Scope;
+			reply(responseCode: number, callback: (uri: string, body: string) => string, headers?: Object): Scope;
+			replyWithFile(responseCode: number, fileName: string): Scope;
+
+			defaultReplyHeaders(headers: Object): Scope;
+			matchHeader(name: string, value: string): Scope;
+
+			filteringPath(regex: RegExp, replace: string): Scope;
+			filteringPath(fn: (path: string) => string): Scope;
+			filteringRequestBody(regex: RegExp, replace: string): Scope;
+			filteringRequestBody(fn: (path: string) => string): Scope;
+
+			persist(): Scope;
+			log(out: () => void): Scope;
+
+			done(): void;
+			isDone(): boolean;
+			restore(): void;
+		}
+
+		export interface Recorder {
+			rec(capture?: boolean): void;
+			play(): string[];
+		}
+
+		export interface Options {
+			allowUnmocked?: boolean;
+		}
+	}
+}

node-ffi/node-ffi.d.ts

@@ -38,13 +38,13 @@ declare module "ffi" {
         /** The type of arguments. */
         argTypes: ref.Type[];
         /** Is set for node-ffi functions. */
-        ffi_type: NodeBuffer;
+        ffi_type: Buffer;
         abi: number;
 
         /** Get a `Callback` pointer of this function type. */
-        toPointer(fn: (...args: any[]) => any): NodeBuffer;
+        toPointer(fn: (...args: any[]) => any): Buffer;
         /** Get a `ForeignFunction` of this function type. */
-        toFunction(buf: NodeBuffer): ForeignFunction;
+        toFunction(buf: Buffer): ForeignFunction;
     }
 
     /** Creates and returns a type for a C function pointer. */
@@ -67,10 +67,10 @@ declare module "ffi" {
      * execution.
      */
     export var ForeignFunction: {
-        new (ptr: NodeBuffer, retType: ref.Type, argTypes: any[], abi?: number): ForeignFunction;
-        new (ptr: NodeBuffer, retType: string, argTypes: any[], abi?: number): ForeignFunction;
-        (ptr: NodeBuffer, retType: ref.Type, argTypes: any[], abi?: number): ForeignFunction;
-        (ptr: NodeBuffer, retType: string, argTypes: any[], abi?: number): ForeignFunction;
+        new (ptr: Buffer, retType: ref.Type, argTypes: any[], abi?: number): ForeignFunction;
+        new (ptr: Buffer, retType: string, argTypes: any[], abi?: number): ForeignFunction;
+        (ptr: Buffer, retType: ref.Type, argTypes: any[], abi?: number): ForeignFunction;
+        (ptr: Buffer, retType: string, argTypes: any[], abi?: number): ForeignFunction;
     }
 
     export interface VariadicForeignFunction {
@@ -96,17 +96,17 @@ declare module "ffi" {
      * contain the same ffi_type argument signature.
      */
     export var VariadicForeignFunction: {
-        new (ptr: NodeBuffer, ret: ref.Type, fixedArgs: any[], abi?: number): VariadicForeignFunction;
-        new (ptr: NodeBuffer, ret: string, fixedArgs: any[], abi?: number): VariadicForeignFunction;
-        (ptr: NodeBuffer, ret: ref.Type, fixedArgs: any[], abi?: number): VariadicForeignFunction;
-        (ptr: NodeBuffer, ret: string, fixedArgs: any[], abi?: number): VariadicForeignFunction;
+        new (ptr: Buffer, ret: ref.Type, fixedArgs: any[], abi?: number): VariadicForeignFunction;
+        new (ptr: Buffer, ret: string, fixedArgs: any[], abi?: number): VariadicForeignFunction;
+        (ptr: Buffer, ret: ref.Type, fixedArgs: any[], abi?: number): VariadicForeignFunction;
+        (ptr: Buffer, ret: string, fixedArgs: any[], abi?: number): VariadicForeignFunction;
     };
 
     export interface DynamicLibrary {
         /** Close library, returns the result of the `dlclose` system function. */
         close(): number;
         /** Get a symbol from this library. */
-        get(symbol: string): NodeBuffer;
+        get(symbol: string): Buffer;
         /** Get the result of the `dlerror` system function. */
         error(): string;
     }
@@ -126,8 +126,8 @@ declare module "ffi" {
             RTLD_GLOBAL: number;
             RTLD_NOLOAD: number;
             RTLD_NODELETE: number;
-            RTLD_NEXT: NodeBuffer;
-            RTLD_DEFAUL: NodeBuffer;
+            RTLD_NEXT: Buffer;
+            RTLD_DEFAUL: Buffer;
         }
 
         new (path?: string, mode?: number): DynamicLibrary;
@@ -140,24 +140,24 @@ declare module "ffi" {
      * accept C callback functions.
      */
     export var Callback: {
-        new (retType: any, argTypes: any[], abi: number, fn: any): NodeBuffer;
-        new (retType: any, argTypes: any[], fn: any): NodeBuffer;
-        (retType: any, argTypes: any[], abi: number, fn: any): NodeBuffer;
-        (retType: any, argTypes: any[], fn: any): NodeBuffer;
+        new (retType: any, argTypes: any[], abi: number, fn: any): Buffer;
+        new (retType: any, argTypes: any[], fn: any): Buffer;
+        (retType: any, argTypes: any[], abi: number, fn: any): Buffer;
+        (retType: any, argTypes: any[], fn: any): Buffer;
     }
 
     export var ffiType: {
         /** Get a `ffi_type *` Buffer appropriate for the given type. */
-        (type: ref.Type): NodeBuffer
+        (type: ref.Type): Buffer
         /** Get a `ffi_type *` Buffer appropriate for the given type. */
-        (type: string): NodeBuffer
+        (type: string): Buffer
         FFI_TYPE: StructType;
     }
 
-    export var CIF: (retType: any, types: any[], abi?: any) => NodeBuffer
-    export var CIF_var: (retType: any, types: any[], numFixedArgs: number, abi?: any) => NodeBuffer;
+    export var CIF: (retType: any, types: any[], abi?: any) => Buffer
+    export var CIF_var: (retType: any, types: any[], numFixedArgs: number, abi?: any) => Buffer;
     export var HAS_OBJC: boolean;
-    export var FFI_TYPES: {[key: string]: NodeBuffer};
+    export var FFI_TYPES: {[key: string]: Buffer};
     export var FFI_OK: number;
     export var FFI_BAD_TYPEDEF: number;
     export var FFI_BAD_ABI: number;
@@ -172,8 +172,8 @@ declare module "ffi" {
     export var RTLD_GLOBAL: number;
     export var RTLD_NOLOAD: number;
     export var RTLD_NODELETE: number;
-    export var RTLD_NEXT: NodeBuffer;
-    export var RTLD_DEFAULT: NodeBuffer;
+    export var RTLD_NEXT: Buffer;
+    export var RTLD_DEFAULT: Buffer;
     export var LIB_EXT: string;
     export var FFI_TYPE: StructType;
 
@@ -198,9 +198,9 @@ declare module "ref" {
         /** The current level of indirection of the buffer. */
         indirection: number;
         /** To invoke when `ref.get` is invoked on a buffer of this type. */
-        get(buffer: NodeBuffer, offset: number): any;
+        get(buffer: Buffer, offset: number): any;
         /** To invoke when `ref.set` is invoked on a buffer of this type. */
-        set(buffer: NodeBuffer, offset: number, value: any): void;
+        set(buffer: Buffer, offset: number, value: any): void;
         /** The name to use during debugging for this datatype. */
         name?: string;
         /** The alignment of this datatype when placed inside a struct. */
@@ -208,22 +208,22 @@ declare module "ref" {
     }
 
     /** A Buffer that references the C NULL pointer. */
-    export var NULL: NodeBuffer;
+    export var NULL: Buffer;
     /** A pointer-sized buffer pointing to NULL. */
-    export var NULL_POINTER: NodeBuffer;
+    export var NULL_POINTER: Buffer;
     /** Get the memory address of buffer. */
-    export function address(buffer: NodeBuffer): number;
+    export function address(buffer: Buffer): number;
     /** Allocate the memory with the given value written to it. */
-    export function alloc(type: Type, value?: any): NodeBuffer;
+    export function alloc(type: Type, value?: any): Buffer;
     /** Allocate the memory with the given value written to it. */
-    export function alloc(type: string, value?: any): NodeBuffer;
+    export function alloc(type: string, value?: any): Buffer;
 
     /**
      * Allocate the memory with the given string written to it with the given
      * encoding (defaults to utf8). The buffer is 1 byte longer than the
      * string itself, and is NULL terminated.
      */
-    export function allocCString(string: string, encoding?: string): NodeBuffer;
+    export function allocCString(string: string, encoding?: string): Buffer;
 
     /** Coerce a type.*/
     export function coerceType(type: Type): Type;
@@ -236,7 +236,7 @@ declare module "ref" {
      * if it's greater than 1 then it merely returns another Buffer, but with
      * one level less indirection.
      */
-    export function deref(buffer: NodeBuffer): any;
+    export function deref(buffer: Buffer): any;
 
     /** Create clone of the type, with decremented indirection level by 1. */
     export function derefType(type: Type): Type;
@@ -245,51 +245,51 @@ declare module "ref" {
     /** Represents the native endianness of the processor ("LE" or "BE"). */
     export var endianness: string;
     /** Check the indirection level and return a dereferenced when necessary. */
-    export function get(buffer: NodeBuffer, offset?: number, type?: Type): any;
+    export function get(buffer: Buffer, offset?: number, type?: Type): any;
     /** Check the indirection level and return a dereferenced when necessary. */
-    export function get(buffer: NodeBuffer, offset?: number, type?: string): any;
+    export function get(buffer: Buffer, offset?: number, type?: string): any;
     /** Get type of the buffer. Create a default type when none exists. */
-    export function getType(buffer: NodeBuffer): Type;
+    export function getType(buffer: Buffer): Type;
     /** Check the NULL. */
-    export function isNull(buffer: NodeBuffer): boolean;
+    export function isNull(buffer: Buffer): boolean;
     /** Read C string until the first NULL. */
-    export function readCString(buffer: NodeBuffer, offset?: number): string;
+    export function readCString(buffer: Buffer, offset?: number): string;
 
     /**
      * Read a big-endian signed 64-bit int.
      * If there is losing precision, then return a string, otherwise a number.
      * @return {number|string}
      */
-    export function readInt64BE(buffer: NodeBuffer, offset?: number): any;
+    export function readInt64BE(buffer: Buffer, offset?: number): any;
 
     /**
      * Read a little-endian signed 64-bit int.
      * If there is losing precision, then return a string, otherwise a number.
      * @return {number|string}
      */
-    export function readInt64LE(buffer: NodeBuffer, offset?: number): any;
+    export function readInt64LE(buffer: Buffer, offset?: number): any;
 
     /** Read a JS Object that has previously been written. */
-    export function readObject(buffer: NodeBuffer, offset?: number): Object;
+    export function readObject(buffer: Buffer, offset?: number): Object;
     /** Read data from the pointer. */
-    export function readPointer(buffer: NodeBuffer, offset?: number,
-                                                   length?: number): NodeBuffer;
+    export function readPointer(buffer: Buffer, offset?: number,
+                                                   length?: number): Buffer;
     /**
      * Read a big-endian unsigned 64-bit int.
      * If there is losing precision, then return a string, otherwise a number.
      * @return {number|string}
      */
-    export function readUInt64BE(buffer: NodeBuffer, offset?: number): any;
+    export function readUInt64BE(buffer: Buffer, offset?: number): any;
 
     /**
      * Read a little-endian unsigned 64-bit int.
      * If there is losing precision, then return a string, otherwise a number.
      * @return {number|string}
      */
-    export function readUInt64LE(buffer: NodeBuffer, offset?: number): any;
+    export function readUInt64LE(buffer: Buffer, offset?: number): any;
 
     /** Create pointer to buffer. */
-    export function ref(buffer: NodeBuffer): NodeBuffer;
+    export function ref(buffer: Buffer): Buffer;
     /** Create clone of the type, with incremented indirection level by 1. */
     export function refType(type: Type): Type;
     /** Create clone of the type, with incremented indirection level by 1. */
@@ -300,66 +300,66 @@ declare module "ref" {
      * This function "attaches" source to the returned buffer to prevent it from
      * being garbage collected.
      */
-    export function reinterpret(buffer: NodeBuffer, size: number,
-                                                  offset?: number): NodeBuffer;
+    export function reinterpret(buffer: Buffer, size: number,
+                                                  offset?: number): Buffer;
     /**
      * Scan past the boundary of the buffer's length until it finds size number
      * of aligned NULL bytes.
      */
-    export function reinterpretUntilZeros(buffer: NodeBuffer, size: number,
-                                          offset?: number): NodeBuffer;
+    export function reinterpretUntilZeros(buffer: Buffer, size: number,
+                                          offset?: number): Buffer;
     
     /** Write pointer if the indirection is 1, otherwise write value. */
-    export function set(buffer: NodeBuffer, offset: number, value: any, type?: Type): void;
+    export function set(buffer: Buffer, offset: number, value: any, type?: Type): void;
     /** Write pointer if the indirection is 1, otherwise write value. */
-    export function set(buffer: NodeBuffer, offset: number, value: any, type?: string): void;
+    export function set(buffer: Buffer, offset: number, value: any, type?: string): void;
     /** Write the string as a NULL terminated. Default encoding is utf8. */
-    export function writeCString(buffer: NodeBuffer, offset: number,
+    export function writeCString(buffer: Buffer, offset: number,
                                  string: string, encoding?: string): void;
     /** Write a big-endian signed 64-bit int. */
-    export function writeInt64BE(buffer: NodeBuffer, offset: number, input: number): void;
+    export function writeInt64BE(buffer: Buffer, offset: number, input: number): void;
     /** Write a big-endian signed 64-bit int. */
-    export function writeInt64BE(buffer: NodeBuffer, offset: number, input: string): void;
+    export function writeInt64BE(buffer: Buffer, offset: number, input: string): void;
     /** Write a little-endian signed 64-bit int. */
-    export function writeInt64LE(buffer: NodeBuffer, offset: number, input: number): void;
+    export function writeInt64LE(buffer: Buffer, offset: number, input: number): void;
     /** Write a little-endian signed 64-bit int. */
-    export function writeInt64LE(buffer: NodeBuffer, offset: number, input: string): void;
+    export function writeInt64LE(buffer: Buffer, offset: number, input: string): void;
     
     /**
      * Write the JS Object. This function "attaches" object to buffer to prevent
      * it from being garbage collected.
      */
-    export function writeObject(buffer: NodeBuffer, offset: number, object: Object): void;
+    export function writeObject(buffer: Buffer, offset: number, object: Object): void;
     
     /**
      * Write the memory address of pointer to buffer at the specified offset. This
      * function "attaches" object to buffer to prevent it from being garbage collected.
      */
-    export function writePointer(buffer: NodeBuffer, offset: number,
-                                                    pointer: NodeBuffer): void;
+    export function writePointer(buffer: Buffer, offset: number,
+                                                    pointer: Buffer): void;
     
     /** Write a little-endian unsigned 64-bit int. */
-    export function writeUInt64BE(buffer: NodeBuffer, offset: number, input: number): void;
+    export function writeUInt64BE(buffer: Buffer, offset: number, input: number): void;
     /** Write a little-endian unsigned 64-bit int. */
-    export function writeUInt64BE(buffer: NodeBuffer, offset: number, input: string): void;
+    export function writeUInt64BE(buffer: Buffer, offset: number, input: string): void;
     
     /**
      * Attach object to buffer such.
      * It prevents object from being garbage collected until buffer does.
      */
-    export function _attach(buffer: NodeBuffer, object: Object): void;
+    export function _attach(buffer: Buffer, object: Object): void;
 
     /** Same as ref.reinterpret, except that this version does not attach buffer. */
-    export function _reinterpret(buffer: NodeBuffer, size: number,
-                                                  offset?: number): NodeBuffer;
+    export function _reinterpret(buffer: Buffer, size: number,
+                                                  offset?: number): Buffer;
     /** Same as ref.reinterpretUntilZeros, except that this version does not attach buffer. */
-    export function _reinterpretUntilZeros(buffer: NodeBuffer, size: number,
-                                          offset?: number): NodeBuffer;
+    export function _reinterpretUntilZeros(buffer: Buffer, size: number,
+                                          offset?: number): Buffer;
     /** Same as ref.writePointer, except that this version does not attach pointer. */
-    export function _writePointer(buffer: NodeBuffer, offset: number,
-                                                    pointer: NodeBuffer): void;
+    export function _writePointer(buffer: Buffer, offset: number,
+                                                    pointer: Buffer): void;
     /** Same as ref.writeObject, except that this version does not attach object. */
-    export function _writeObject(buffer: NodeBuffer, offset: number, object: Object): void;
+    export function _writeObject(buffer: Buffer, offset: number, object: Object): void;
 
     /** Default types. */
     export var types: {
@@ -375,7 +375,7 @@ declare module "ref" {
     };
 }
 
-interface NodeBuffer {
+interface Buffer {
     /** Shorthand for `ref.address`. */
     address(): number;
     /** Shorthand for `ref.deref`. */
@@ -397,11 +397,11 @@ interface NodeBuffer {
     /** Shorthand for `ref.readUInt64LE`. */
     readUInt64LE(offset?: number): string;
     /** Shorthand for `ref.ref`. */
-    ref(): NodeBuffer;
+    ref(): Buffer;
     /** Shorthand for `ref.reinterpret`. */
-    reinterpret(size: number, offset?: number): NodeBuffer;
+    reinterpret(size: number, offset?: number): Buffer;
     /** Shorthand for `ref.reinterpretUntilZeros`. */
-    reinterpretUntilZeros(size: number, offset?: number): NodeBuffer;
+    reinterpretUntilZeros(size: number, offset?: number): Buffer;
     /** Shorthand for `ref.writeCString`. */
     writeCString(offset: number, string: string, encoding?: string): void;
     /** Shorthand for `ref.writeInt64BE`. */
@@ -415,7 +415,7 @@ interface NodeBuffer {
     /** Shorthand for `ref.writeObject`. */
     writeObject(offset: number, object: Object): void;
     /** Shorthand for `ref.writePointer`. */
-    writePointer(offset: number, pointer: NodeBuffer): void;
+    writePointer(offset: number, pointer: Buffer): void;
     /** Shorthand for `ref.writeUInt64BE`. */
     writeUInt64BE(offset: number, input: number): any;
     /** Shorthand for `ref.writeUInt64BE`. */
@@ -447,21 +447,21 @@ declare module "ref-array" {
          * for the ArrayType. The "length" of the Array is determined by searching
          * through the buffer's contents until an aligned NULL pointer is encountered.
          */
-        untilZeros(buffer: NodeBuffer): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
+        untilZeros(buffer: Buffer): { [i: number]: T; length: number; toArray(): T[];
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
 
         new (length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
         new (data: number[], length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
-        new (data: NodeBuffer, length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
+        new (data: Buffer, length?: number): { [i: number]: T; length: number; toArray(): T[];
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
         (length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
         (data: number[], length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
-        (data: NodeBuffer, length?: number): { [i: number]: T; length: number; toArray(): T[];
-            toJSON(): T[]; inspect(): string; buffer: NodeBuffer; ref(): NodeBuffer; };
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
+        (data: Buffer, length?: number): { [i: number]: T; length: number; toArray(): T[];
+            toJSON(): T[]; inspect(): string; buffer: Buffer; ref(): Buffer; };
     }
 
     /**
@@ -494,10 +494,10 @@ declare module "ref-struct" {
      */
     interface StructType extends ref.Type {
         /** Pass it an existing Buffer instance to use that as the backing buffer. */
-        new (arg: NodeBuffer, data?: {}): any;
+        new (arg: Buffer, data?: {}): any;
         new (data?: {}): any;
         /** Pass it an existing Buffer instance to use that as the backing buffer. */
-        (arg: NodeBuffer, data?: {}): any;
+        (arg: Buffer, data?: {}): any;
         (data?: {}): any;
 
         fields: {[key: string]: {type: ref.Type}};
@@ -551,10 +551,10 @@ declare module "ref-union" {
      */
     interface UnionType extends ref.Type {
         /** Pass it an existing Buffer instance to use that as the backing buffer. */
-        new (arg: NodeBuffer, data?: {}): any;
+        new (arg: Buffer, data?: {}): any;
         new (data?: {}): any;
         /** Pass it an existing Buffer instance to use that as the backing buffer. */
-        (arg: NodeBuffer, data?: {}): any;
+        (arg: Buffer, data?: {}): any;
         (data?: {}): any;
 
         fields: {[key: string]: {type: ref.Type}};

node-uuid/node-uuid.d.ts

@@ -0,0 +1,49 @@
+// Type definitions for node-uuid.js
+// Project: https://github.com/broofa/node-uuid
+// Definitions by: Jeff May <https://github.com/jeffmay>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+interface UUIDOptions {
+
+    /**
+     * Node id as Array of 6 bytes (per 4.1.6).
+     * Default: Randomly generated ID. See note 1.
+     */
+    node: any[]
+
+    /**
+     * (Number between 0 - 0x3fff) RFC clock sequence.
+     * Default: An internally maintained clockseq is used.
+     */
+    clockseq: number
+
+    /**
+     * (Number | Date) Time in milliseconds since unix Epoch.
+     * Default: The current time is used.
+     */
+    msecs: any
+
+    /**
+     * (Number between 0-9999) additional time, in 100-nanosecond units. Ignored if msecs is unspecified.
+     * Default: internal uuid counter is used, as per 4.2.1.2.
+     */
+    nsecs: number
+}
+
+interface UUID {
+    v1(options?: UUIDOptions, buffer?: number[], offset?: number): string
+    v1(options?: UUIDOptions, buffer?: NodeBuffer, offset?: number): string
+
+    v2(options?: UUIDOptions, buffer?: number[], offset?: number): string
+    v2(options?: UUIDOptions, buffer?: NodeBuffer, offset?: number): string
+
+    v3(options?: UUIDOptions, buffer?: number[], offset?: number): string
+    v3(options?: UUIDOptions, buffer?: NodeBuffer, offset?: number): string
+
+    v4(options?: UUIDOptions, buffer?: number[], offset?: number): string
+    v4(options?: UUIDOptions, buffer?: NodeBuffer, offset?: number): string
+}
+
+declare var uuid: UUID;

node-uuid/node-uuid.tests.ts

@@ -0,0 +1,22 @@
+/// <reference path="node-uuid.d.ts" />
+
+var uid1: string = uuid.v1()
+var uid2: string = uuid.v2()
+var uid3: string = uuid.v3()
+var uid4: string = uuid.v4()
+
+var options: UUIDOptions = {
+  node: [],
+  clockseq: 2,
+  nsecs: 3,
+  msecs: new Date()
+}
+
+var padding: number[] = [0, 1, 2]
+
+var offset: number = 15
+
+uuid.v1(options, padding, offset)
+uuid.v2(options, padding, offset)
+uuid.v3(options, padding, offset)
+uuid.v4(options, padding, offset)

node/node-0.8.8.d.ts

@@ -44,22 +44,22 @@ declare var module: {
 // Same as module.exports
 declare var exports: any;
 declare var SlowBuffer: {
-    new (str: string, encoding?: string): NodeBuffer;
-    new (size: number): NodeBuffer;
-    new (array: any[]): NodeBuffer;
-    prototype: NodeBuffer;
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
     isBuffer(obj: any): boolean;
     byteLength(string: string, encoding?: string): number;
-    concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+    concat(list: Buffer[], totalLength?: number): Buffer;
 };
 declare var Buffer: {
-    new (str: string, encoding?: string): NodeBuffer;
-    new (size: number): NodeBuffer;
-    new (array: any[]): NodeBuffer;
-    prototype: NodeBuffer;
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
     isBuffer(obj: any): boolean;
     byteLength(string: string, encoding?: string): number;
-    concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+    concat(list: Buffer[], totalLength?: number): Buffer;
 }
 
 /************************************************
@@ -82,10 +82,10 @@ interface EventEmitter {
 interface WritableStream extends EventEmitter {
     writable: boolean;
     write(str: string, encoding?: string, fd?: string): boolean;
-    write(buffer: NodeBuffer): boolean;
+    write(buffer: Buffer): boolean;
     end(): void;
     end(str: string, enconding: string): void;
-    end(buffer: NodeBuffer): void;
+    end(buffer: Buffer): void;
     destroy(): void;
     destroySoon(): void;
 }
@@ -155,13 +155,13 @@ interface NodeProcess extends EventEmitter {
 }
 
 // Buffer class
-interface NodeBuffer {
+interface Buffer {
     [index: number]: number;
     write(string: string, offset?: number, length?: number, encoding?: string): number;
     toString(encoding?: string, start?: number, end?: number): string;
     length: number;
-    copy(targetBuffer: NodeBuffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
-    slice(start?: number, end?: number): NodeBuffer;
+    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;
@@ -247,7 +247,7 @@ declare module "http" {
     export interface ServerResponse extends events.NodeEventEmitter, stream.WritableStream {
         // Extended base methods
         write(str: string, encoding?: string, fd?: string): boolean;
-        write(buffer: NodeBuffer): boolean;
+        write(buffer: Buffer): boolean;
 
         writeContinue(): void;
         writeHead(statusCode: number, reasonPhrase?: string, headers?: any): void;
@@ -264,7 +264,7 @@ declare module "http" {
     export interface ClientRequest extends events.NodeEventEmitter, stream.WritableStream {
         // Extended base methods
         write(str: string, encoding?: string, fd?: string): boolean;
-        write(buffer: NodeBuffer): boolean;
+        write(buffer: Buffer): boolean;
 
         write(chunk: any, encoding?: string): void;
         end(data?: any, encoding?: string): void;
@@ -349,13 +349,13 @@ declare module "zlib" {
     export function createInflateRaw(options: ZlibOptions): InflateRaw;
     export function createUnzip(options: ZlibOptions): Unzip;
 
-    export function deflate(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function gzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function gunzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function inflate(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
-    export function unzip(buf: NodeBuffer, callback: (error: Error, result) =>void ): void;
+    export function deflate(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function deflateRaw(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function gzip(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function gunzip(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function inflate(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function inflateRaw(buf: Buffer, callback: (error: Error, result) =>void ): void;
+    export function unzip(buf: Buffer, callback: (error: Error, result) =>void ): void;
 
     // Constants
     export var Z_NO_FLUSH: number;
@@ -556,8 +556,8 @@ declare module "child_process" {
         timeout?: number;
         maxBuffer?: number;
         killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
-    export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    }, 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, args: string[], options: {
         cwd?: string;
         stdio?: any;
@@ -567,7 +567,7 @@ declare module "child_process" {
         timeout?: number;
         maxBuffer?: string;
         killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    }, callback: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
     export function fork(modulePath: string, args?: string[], options?: {
         cwd?: string;
         env?: any;
@@ -615,7 +615,7 @@ declare module "net" {
     export interface NodeSocket extends stream.ReadWriteStream {
         // Extended base methods
         write(str: string, encoding?: string, fd?: string): boolean;
-        write(buffer: NodeBuffer): boolean;
+        write(buffer: Buffer): boolean;
 
         connect(port: number, host?: string, connectionListener?: Function): void;
         connect(path: string, connectionListener?: Function): void;
@@ -668,7 +668,7 @@ declare module "dgram" {
     export function createSocket(type: string, callback?: Function): Socket;
 
     interface Socket extends events.NodeEventEmitter {
-        send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
+        send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
         bind(port: number, address?: string): void;
         close(): void;
         address: { address: string; family: string; port: number; };
@@ -761,13 +761,13 @@ declare module "fs" {
     export function futimesSync(fd: string, atime: number, mtime: number): void;
     export function fsync(fd: string, callback?: Function): void;
     export function fsyncSync(fd: string): void;
-    export function write(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, written: number, buffer: NodeBuffer) =>any): void;
-    export function writeSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): void;
-    export function read(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: Error, bytesRead: number, buffer: NodeBuffer) => void): void;
-    export function readSync(fd: string, buffer: NodeBuffer, offset: number, length: number, position: number): any[];
+    export function write(fd: string, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: Error, written: number, buffer: Buffer) =>any): void;
+    export function writeSync(fd: string, buffer: Buffer, offset: number, length: number, position: number): void;
+    export function read(fd: string, buffer: Buffer, offset: number, length: number, position: number, callback?: (err: Error, bytesRead: number, buffer: Buffer) => void): void;
+    export function readSync(fd: string, buffer: Buffer, offset: number, length: number, position: number): any[];
     export function readFile(filename: string, encoding: string, callback: (err: Error, data: string) => void ): void;
-    export function readFile(filename: string, callback: (err: Error, data: NodeBuffer) => void ): void;
-    export function readFileSync(filename: string): NodeBuffer;
+    export function readFile(filename: string, callback: (err: Error, data: Buffer) => void ): void;
+    export function readFileSync(filename: string): Buffer;
     export function readFileSync(filename: string, encoding: string): string;
     export function writeFile(filename: string, data: any, callback?: (err) => void): void;
     export function writeFile(filename: string, data: any, encoding?: string, callback?: (err) => void): void;
@@ -811,8 +811,8 @@ declare module "path" {
 
 declare module "string_decoder" {
     export interface NodeStringDecoder {
-        write(buffer: NodeBuffer): string;
-        detectIncompleteChar(buffer: NodeBuffer): number;
+        write(buffer: Buffer): string;
+        detectIncompleteChar(buffer: Buffer): number;
     }
     export var StringDecoder: {
         new (encoding: string): NodeStringDecoder;
@@ -963,7 +963,7 @@ declare module "crypto" {
     }
     export function getDiffieHellman(group_name: string): DiffieHellman;
     export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
-    export function randomBytes(size: number, callback?: (err: Error, buf: NodeBuffer) =>void );
+    export function randomBytes(size: number, callback?: (err: Error, buf: Buffer) =>void );
 }
 
 declare module "stream" {
@@ -972,10 +972,10 @@ declare module "stream" {
     export interface WritableStream extends events.NodeEventEmitter {
         writable: boolean;
         write(str: string, encoding?: string, fd?: string): boolean;
-        write(buffer: NodeBuffer): boolean;
+        write(buffer: Buffer): boolean;
         end(): void;
         end(str: string, enconding: string): void;
-        end(buffer: NodeBuffer): void;
+        end(buffer: Buffer): void;
         destroy(): void;
         destroySoon(): void;
     }

node/node-tests.ts

@@ -39,7 +39,7 @@ fs.writeFile("Harry Potter",
     assert.ifError);
 
 var content: string,
-    buffer: NodeBuffer;
+    buffer: Buffer;
 
 content = fs.readFileSync('testfile', 'utf8');
 content = fs.readFileSync('testfile', {encoding : 'utf8'});

node/node.d.ts

@@ -4,7 +4,7 @@
 
 /************************************************
 *                                               *
-*               Node.js v0.10.1 API              *
+*               Node.js v0.10.1 API             *
 *                                               *
 ************************************************/
 
@@ -13,17 +13,17 @@
 *                   GLOBAL                      *
 *                                               *
 ************************************************/
-declare var process: NodeProcess;
+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[]): NodeTimer;
-declare function clearTimeout(timeoutId: NodeTimer): void;
-declare function setInterval(callback: (...args: any[]) => void , ms: number , ...args: any[]): NodeTimer;
-declare function clearInterval(intervalId: NodeTimer): void;
-declare function setImmediate(callback: (...args: any[]) => void , ...args: any[]): any;
+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: {
@@ -32,7 +32,7 @@ declare var require: {
     cache: any;
     extensions: any;
     main: any;
-}
+};
 
 declare var module: {
     exports: any;
@@ -42,147 +42,167 @@ declare var module: {
     loaded: boolean;
     parent: any;
     children: any[];
-}
+};
 
 // Same as module.exports
 declare var exports: any;
 declare var SlowBuffer: {
-    new (str: string, encoding?: string): NodeBuffer;
-    new (size: number): NodeBuffer;
-    new (array: any[]): NodeBuffer;
-    prototype: NodeBuffer;
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
     isBuffer(obj: any): boolean;
     byteLength(string: string, encoding?: string): number;
-    concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+    concat(list: Buffer[], totalLength?: number): Buffer;
 };
+
+
+// Buffer class
+interface Buffer extends NodeBuffer {}
 declare var Buffer: {
-    new (str: string, encoding?: string): NodeBuffer;
-    new (size: number): NodeBuffer;
-    new (array: any[]): NodeBuffer;
-    prototype: NodeBuffer;
+    new (str: string, encoding?: string): Buffer;
+    new (size: number): Buffer;
+    new (array: any[]): Buffer;
+    prototype: Buffer;
     isBuffer(obj: any): boolean;
     byteLength(string: string, encoding?: string): number;
-    concat(list: NodeBuffer[], totalLength?: number): NodeBuffer;
+    concat(list: Buffer[], totalLength?: number): Buffer;
 }
 
 /************************************************
 *                                               *
-*                   INTERFACES                  *
+*               GLOBAL INTERFACES               *
 *                                               *
 ************************************************/
+declare module NodeJS {
+    export interface ErrnoException extends Error {
+        errno?: any;
+        code?: string;
+        path?: string;
+        syscall?: string;
+    }
 
-interface ErrnoException extends Error {
-    errno?: any;
-    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;
+    }
 
-interface NodeEventEmitter {
-    addListener(event: string, listener: Function): NodeEventEmitter;
-    on(event: string, listener: Function): NodeEventEmitter;
-    once(event: string, listener: Function): NodeEventEmitter;
-    removeListener(event: string, listener: Function): NodeEventEmitter;
-    removeAllListeners(event?: string): NodeEventEmitter;
-    setMaxListeners(n: number): void;
-    listeners(event: string): Function[];
-    emit(event: string, ...args: any[]): boolean;
-}
+    export interface ReadableStream extends EventEmitter {
+        readable: boolean;
+        read(size?: number): any;
+        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;
+    }
 
-interface ReadableStream extends NodeEventEmitter {
-    readable: boolean;
-    read(size?: number): any;
-    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: NodeBuffer): 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;
+    }
 
-interface WritableStream extends NodeEventEmitter {
-    writable: boolean;
-    write(buffer: NodeBuffer, cb?: Function): boolean;
-    write(str: string, cb?: Function): boolean;
-    write(str: string, encoding?: string, cb?: Function): boolean;
-    end(): void;
-    end(buffer: NodeBuffer, cb?: Function): void;
-    end(str: string, cb?: Function): void;
-    end(str: string, encoding?: string, cb?: Function): void;
-}
+    export interface ReadWriteStream extends ReadableStream, WritableStream {}
 
-interface ReadWriteStream extends ReadableStream, WritableStream { }
-
-interface NodeProcess extends NodeEventEmitter {
-    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[];
+    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;
         };
-        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[];
+        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;
+        // Worker
+        send?(message: any, sendHandle?: any): void;
+    }
+
+    export interface Timer {
+        ref() : void;
+        unref() : void;
+    }
 }
 
-// Buffer class
+/**
+ * @deprecated
+ */
 interface NodeBuffer {
     [index: number]: number;
     write(string: string, offset?: number, length?: number, encoding?: string): number;
     toString(encoding?: string, start?: number, end?: number): string;
     length: number;
-    copy(targetBuffer: NodeBuffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
-    slice(start?: number, end?: number): NodeBuffer;
+    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;
@@ -214,11 +234,6 @@ interface NodeBuffer {
     fill(value: any, offset?: number, end?: number): void;
 }
 
-interface NodeTimer {
-    ref() : void;
-    unref() : void;
-}
-
 /************************************************
 *                                               *
 *                   MODULES                     *
@@ -232,7 +247,7 @@ declare module "querystring" {
 }
 
 declare module "events" {
-    export class EventEmitter implements NodeEventEmitter {
+    export class EventEmitter implements NodeJS.EventEmitter {
         static listenerCount(emitter: EventEmitter, event: string): number;
 
         addListener(event: string, listener: Function): EventEmitter;
@@ -251,7 +266,7 @@ declare module "http" {
     import net = require("net");
     import stream = require("stream");
 
-    export interface Server extends NodeEventEmitter {
+    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;
@@ -259,7 +274,7 @@ declare module "http" {
         address(): { port: number; family: string; address: string; };
         maxHeadersCount: number;
     }
-    export interface ServerRequest extends NodeEventEmitter, ReadableStream {
+    export interface ServerRequest extends events.EventEmitter, stream.Readable {
         method: string;
         url: string;
         headers: any;
@@ -270,10 +285,10 @@ declare module "http" {
         resume(): void;
         connection: net.Socket;
     }
-    export interface ServerResponse extends NodeEventEmitter, WritableStream {
+    export interface ServerResponse extends events.EventEmitter, stream.Writable {
         // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
+        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;
@@ -291,15 +306,15 @@ declare module "http" {
 
         // Extended base methods
         end(): void;
-        end(buffer: NodeBuffer, cb?: Function): 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 NodeEventEmitter, WritableStream {
+    export interface ClientRequest extends events.EventEmitter, stream.Writable {
         // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
+        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;
@@ -312,12 +327,12 @@ declare module "http" {
 
         // Extended base methods
         end(): void;
-        end(buffer: NodeBuffer, cb?: Function): 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 ClientResponse extends NodeEventEmitter, ReadableStream {
+    export interface ClientResponse extends events.EventEmitter, stream.Readable {
         statusCode: number;
         httpVersion: string;
         headers: any;
@@ -380,13 +395,13 @@ 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 ReadWriteStream { }
-    export interface Gunzip extends ReadWriteStream { }
-    export interface Deflate extends ReadWriteStream { }
-    export interface Inflate extends ReadWriteStream { }
-    export interface DeflateRaw extends ReadWriteStream { }
-    export interface InflateRaw extends ReadWriteStream { }
-    export interface Unzip extends ReadWriteStream { }
+    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;
@@ -396,13 +411,13 @@ declare module "zlib" {
     export function createInflateRaw(options?: ZlibOptions): InflateRaw;
     export function createUnzip(options?: ZlibOptions): Unzip;
 
-    export function deflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function deflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function gzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function gunzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function inflate(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function inflateRaw(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
-    export function unzip(buf: NodeBuffer, callback: (error: Error, result: any) =>void ): void;
+    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;
@@ -502,8 +517,8 @@ declare module "https" {
     };
     export interface Server extends tls.Server { }
     export function createServer(options: ServerOptions, requestListener?: Function): Server;
-    export function request(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
-    export function get(options: RequestOptions, callback?: (res: NodeEventEmitter) =>void ): http.ClientRequest;
+    export function request(options: RequestOptions, callback?: (res: events.EventEmitter) =>void ): http.ClientRequest;
+    export function get(options: RequestOptions, callback?: (res: events.EventEmitter) =>void ): http.ClientRequest;
     export var globalAgent: Agent;
 }
 
@@ -526,8 +541,8 @@ declare module "repl" {
 
     export interface ReplOptions {
         prompt?: string;
-        input?: ReadableStream;
-        output?: WritableStream;
+        input?: NodeJS.ReadableStream;
+        output?: NodeJS.WritableStream;
         terminal?: boolean;
         eval?: Function;
         useColors?: boolean;
@@ -535,14 +550,14 @@ declare module "repl" {
         ignoreUndefined?: boolean;
         writer?: Function;
     }
-    export function start(options: ReplOptions): NodeEventEmitter;
+    export function start(options: ReplOptions): events.EventEmitter;
 }
 
 declare module "readline" {
     import events = require("events");
     import stream = require("stream");
 
-    export interface ReadLine extends NodeEventEmitter {
+    export interface ReadLine extends events.EventEmitter {
         setPrompt(prompt: string, length: number): void;
         prompt(preserveCursor?: boolean): void;
         question(query: string, callback: Function): void;
@@ -552,8 +567,8 @@ declare module "readline" {
         write(data: any, key?: any): void;
     }
     export interface ReadLineOptions {
-        input: ReadableStream;
-        output: WritableStream;
+        input: NodeJS.ReadableStream;
+        output: NodeJS.WritableStream;
         completer?: Function;
         terminal?: boolean;
     }
@@ -577,10 +592,10 @@ declare module "child_process" {
     import events = require("events");
     import stream = require("stream");
 
-    export interface ChildProcess extends NodeEventEmitter {
-        stdin: WritableStream;
-        stdout: ReadableStream;
-        stderr: ReadableStream;
+    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;
@@ -603,8 +618,8 @@ declare module "child_process" {
         timeout?: number;
         maxBuffer?: number;
         killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
-    export function exec(command: string, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    }, 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, args: string[], options: {
         cwd?: string;
         stdio?: any;
@@ -614,7 +629,7 @@ declare module "child_process" {
         timeout?: number;
         maxBuffer?: string;
         killSignal?: string;
-    }, callback: (error: Error, stdout: NodeBuffer, stderr: NodeBuffer) =>void ): ChildProcess;
+    }, callback: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
     export function fork(modulePath: string, args?: string[], options?: {
         cwd?: string;
         env?: any;
@@ -674,10 +689,10 @@ declare module "dns" {
 declare module "net" {
     import stream = require("stream");
 
-    export interface Socket extends ReadWriteStream {
+    export interface Socket extends stream.Duplex {
         // Extended base methods
-        write(buffer: NodeBuffer): boolean;
-        write(buffer: NodeBuffer, cb?: Function): boolean;
+        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;
@@ -701,7 +716,7 @@ declare module "net" {
 
         // Extended base methods
         end(): void;
-        end(buffer: NodeBuffer, cb?: Function): 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;
@@ -738,8 +753,8 @@ declare module "dgram" {
 
     export function createSocket(type: string, callback?: Function): Socket;
 
-    interface Socket extends NodeEventEmitter {
-        send(buf: NodeBuffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
+    interface Socket extends events.EventEmitter {
+        send(buf: Buffer, offset: number, length: number, port: number, address: string, callback?: Function): void;
         bind(port: number, address?: string): void;
         close(): void;
         address: { address: string; family: string; port: number; };
@@ -753,6 +768,7 @@ declare module "dgram" {
 
 declare module "fs" {
     import stream = require("stream");
+    import events = require("events");
 
     interface Stats {
         isFile(): boolean;
@@ -777,97 +793,97 @@ declare module "fs" {
         ctime: Date;
     }
 
-    interface FSWatcher extends NodeEventEmitter {
+    interface FSWatcher extends events.EventEmitter {
         close(): void;
     }
 
-    export interface ReadStream extends ReadableStream { }
-    export interface WriteStream extends WritableStream { }
+    export interface ReadStream extends stream.Readable {}
+    export interface WriteStream extends stream.Writable {}
 
-    export function rename(oldPath: string, newPath: string, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function truncate(path: string, len: number, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function ftruncate(fd: number, len: number, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): 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?: ErrnoException) => void): 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?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function chmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function fchmod(fd: number, mode: string, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function lchmod(path: string, mode: string, callback?: (err?: ErrnoException) => void): 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: ErrnoException, stats: Stats) => any): void;
-    export function lstat(path: string, callback?: (err: ErrnoException, stats: Stats) => any): void;
-    export function fstat(fd: number, callback?: (err: ErrnoException, stats: Stats) => any): 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?: ErrnoException) => void): void;
+    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?: ErrnoException) => void): 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: ErrnoException, linkString: string) => any): 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: ErrnoException, resolvedPath: string) => any): void;
-    export function realpath(path: string, cache: {[path: string]: string}, callback: (err: ErrnoException, resolvedPath: string) =>any): void;
+    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?: ErrnoException) => void): void;
+    export function unlink(path: string, callback?: (err?: NodeJS.ErrnoException) => void): void;
     export function unlinkSync(path: string): void;
-    export function rmdir(path: string, callback?: (err?: ErrnoException) => void): 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?: ErrnoException) => void): void;
-    export function mkdir(path: string, mode: number, callback?: (err?: ErrnoException) => void): void;
-    export function mkdir(path: string, mode: string, callback?: (err?: ErrnoException) => void): 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: ErrnoException, files: string[]) => void): 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?: ErrnoException) => void): void;
+    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: ErrnoException, fd: number) => any): void;
-    export function open(path: string, flags: string, mode: number, callback?: (err: ErrnoException, fd: number) => any): void;
-    export function open(path: string, flags: string, mode: string, callback?: (err: ErrnoException, fd: number) => any): 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?: ErrnoException) => void): void;
+    export function utimes(path: string, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
     export function utimesSync(path: string, atime: number, mtime: number): void;
-    export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: ErrnoException) => void): void;
+    export function futimes(fd: number, atime: number, mtime: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
     export function futimesSync(fd: number, atime: number, mtime: number): void;
-    export function fsync(fd: number, callback?: (err?: ErrnoException) => void): void;
+    export function fsync(fd: number, callback?: (err?: NodeJS.ErrnoException) => void): void;
     export function fsyncSync(fd: number): void;
-    export function write(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, written: number, buffer: NodeBuffer) => void): void;
-    export function writeSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-    export function read(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number, callback?: (err: ErrnoException, bytesRead: number, buffer: NodeBuffer) => void): void;
-    export function readSync(fd: number, buffer: NodeBuffer, offset: number, length: number, position: number): number;
-    export function readFile(filename: string, encoding: string, callback: (err: ErrnoException, data: string) => void): void;
-    export function readFile(filename: string, options: { encoding: string; flag?: string; }, callback: (err: ErrnoException, data: string) => void): void;
-    export function readFile(filename: string, options: { flag?: string; }, callback: (err: ErrnoException, data: NodeBuffer) => void): void;
-    export function readFile(filename: string, callback: (err: ErrnoException, data: NodeBuffer) => void ): 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; }): NodeBuffer;
-    export function writeFile(filename: string, data: any, callback?: (err: ErrnoException) => void): void;
-    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: number; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function writeFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
+    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: ErrnoException) => void): void;
-    export function appendFile(filename: string, data: any, options: { encoding?: string; mode?: string; flag?: string; }, callback?: (err: ErrnoException) => void): void;
-    export function appendFile(filename: string, data: any, callback?: (err: ErrnoException) => void): 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;
@@ -911,8 +927,8 @@ declare module "path" {
 
 declare module "string_decoder" {
     export interface NodeStringDecoder {
-        write(buffer: NodeBuffer): string;
-        detectIncompleteChar(buffer: NodeBuffer): number;
+        write(buffer: Buffer): string;
+        detectIncompleteChar(buffer: Buffer): number;
     }
     export var StringDecoder: {
         new (encoding: string): NodeStringDecoder;
@@ -974,7 +990,7 @@ declare module "tls" {
         connections: number;
     }
 
-    export interface ClearTextStream extends ReadWriteStream {
+    export interface ClearTextStream extends stream.Duplex {
         authorized: boolean;
         authorizationError: Error;
         getPeerCertificate(): any;
@@ -1031,9 +1047,9 @@ declare module "crypto" {
         update(data: any, input_encoding?: string, output_encoding?: string): string;
         final(output_encoding?: string): string;
         setAutoPadding(auto_padding: boolean): void;
+        createDecipher(algorithm: string, password: any): Decipher;
+        createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
     }
-    export function createDecipher(algorithm: string, password: any): Decipher;
-    export function createDecipheriv(algorithm: string, key: any, iv: any): Decipher;
     interface Decipher {
         update(data: any, input_encoding?: string, output_encoding?: string): void;
         final(output_encoding?: string): string;
@@ -1063,11 +1079,11 @@ declare module "crypto" {
     }
     export function getDiffieHellman(group_name: string): DiffieHellman;
     export function pbkdf2(password: string, salt: string, iterations: number, keylen: number, callback: (err: Error, derivedKey: string) => any): void;
-    export function pbkdf2Sync(password: string, salt: string, iterations: number, keylen: number) : NodeBuffer;
-    export function randomBytes(size: number): NodeBuffer;
-    export function randomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): void;
-    export function pseudoRandomBytes(size: number): NodeBuffer;
-    export function pseudoRandomBytes(size: number, callback: (err: Error, buf: NodeBuffer) =>void ): 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" {
@@ -1079,7 +1095,7 @@ declare module "stream" {
         objectMode?: boolean;
     }
 
-    export class Readable extends events.EventEmitter implements ReadableStream {
+    export class Readable extends events.EventEmitter implements NodeJS.ReadableStream {
         readable: boolean;
         constructor(opts?: ReadableOptions);
         _read(size: number): void;
@@ -1087,11 +1103,11 @@ declare module "stream" {
         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;
+        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: NodeBuffer): void;
-        wrap(oldStream: ReadableStream): ReadableStream;
+        unshift(chunk: Buffer): void;
+        wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
         push(chunk: any, encoding?: string): boolean;
     }
 
@@ -1100,16 +1116,16 @@ declare module "stream" {
         decodeStrings?: boolean;
     }
 
-    export class Writable extends events.EventEmitter implements WritableStream {
+    export class Writable extends events.EventEmitter implements NodeJS.WritableStream {
         writable: boolean;
         constructor(opts?: WritableOptions);
-        _write(data: NodeBuffer, encoding: string, callback: Function): void;
+        _write(data: Buffer, encoding: string, callback: Function): void;
         _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: NodeBuffer, cb?: Function): 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: NodeBuffer, cb?: Function): void;
+        end(buffer: Buffer, cb?: Function): void;
         end(str: string, cb?: Function): void;
         end(str: string, encoding?: string, cb?: Function): void;
     }
@@ -1119,16 +1135,16 @@ declare module "stream" {
     }
 
     // Note: Duplex extends both Readable and Writable.
-    export class Duplex extends Readable implements ReadWriteStream {
+    export class Duplex extends Readable implements NodeJS.ReadWriteStream {
         writable: boolean;
         constructor(opts?: DuplexOptions);
-        _write(data: NodeBuffer, encoding: string, callback: Function): void;
+        _write(data: Buffer, encoding: string, callback: Function): void;
         _write(data: string, encoding: string, callback: Function): void;
-        write(buffer: NodeBuffer, cb?: Function): 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: NodeBuffer, cb?: Function): void;
+        end(buffer: Buffer, cb?: Function): void;
         end(str: string, cb?: Function): void;
         end(str: string, encoding?: string, cb?: Function): void;
     }
@@ -1136,28 +1152,28 @@ declare module "stream" {
     export interface TransformOptions extends ReadableOptions, WritableOptions {}
 
     // Note: Transform lacks the _read and _write methods of Readable/Writable.
-    export class Transform extends events.EventEmitter implements ReadWriteStream {
+    export class Transform extends events.EventEmitter implements NodeJS.ReadWriteStream {
         readable: boolean;
         writable: boolean;
         constructor(opts?: TransformOptions);
-        _transform(chunk: NodeBuffer, encoding: string, callback: Function): void;
+        _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 WritableStream>(destination: T, options?: { end?: boolean; }): T;
-        unpipe<T extends WritableStream>(destination?: T): 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: NodeBuffer): void;
-        wrap(oldStream: ReadableStream): ReadableStream;
+        unshift(chunk: Buffer): void;
+        wrap(oldStream: NodeJS.ReadableStream): NodeJS.ReadableStream;
         push(chunk: any, encoding?: string): boolean;
-        write(buffer: NodeBuffer, cb?: Function): 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: NodeBuffer, cb?: Function): void;
+        end(buffer: Buffer, cb?: Function): void;
         end(str: string, cb?: Function): void;
         end(str: string, encoding?: string, cb?: Function): void;
     }
@@ -1250,8 +1266,8 @@ declare module "domain" {
 
     export class Domain extends events.EventEmitter {
         run(fn: Function): void;
-        add(emitter: NodeEventEmitter): void;
-        remove(emitter: NodeEventEmitter): 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;

nodeunit/nodeunit-tests.ts

@@ -0,0 +1,59 @@
+/// <reference path="nodeunit.d.ts" />
+
+import nodeunit = require('nodeunit');
+
+var num: number;
+var value: any;
+var actual: any;
+var expected: any;
+var message: string;
+var operator: string;
+var error: any;
+var block: () =>{
+
+};
+
+export var testGroup: nodeunit.ITestGroup = {
+	setUp: function (callback: nodeunit.ICallbackFunction) {
+		callback();
+	},
+	tearDown: function (callback: nodeunit.ICallbackFunction) {
+		callback();
+	},
+	test1: function (test: nodeunit.Test) {
+		test.expect(num);
+
+		test.fail(actual, expected, message, operator);
+		test.assert(value, message);
+		test.ok(value);
+		test.ok(value, message);
+		test.equal(actual, expected);
+		test.equal(actual, expected, message);
+		test.notEqual(actual, expected);
+		test.notEqual(actual, expected, message);
+		test.deepEqual(actual, expected);
+		test.deepEqual(actual, expected, message);
+		test.notDeepEqual(actual, expected);
+		test.notDeepEqual(actual, expected, message);
+		test.strictEqual(actual, expected);
+		test.strictEqual(actual, expected, message);
+		test.notStrictEqual(actual, expected);
+		test.notStrictEqual(actual, expected, message);
+		test.throws(block);
+		test.throws(block, error);
+		test.throws(block, error, message);
+		test.doesNotThrow(block);
+		test.doesNotThrow(block, error);
+		test.doesNotThrow(block, error, message);
+		test.ifError(value);
+
+		//assertion wrappers
+		test.equals(actual, expected);
+		test.equals(actual, expected, message);
+		test.same(actual, expected);
+		test.same(actual, expected, message);
+
+		test.done(error);
+		test.done();
+	}
+};

nodeunit/nodeunit.d.ts

@@ -0,0 +1,59 @@
+// Type definitions for nodeunit
+// Project: https://github.com/caolan/nodeunit
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/nodeunit.d.ts
+
+declare module 'nodeunit' {
+	export interface Test {
+		done: ICallbackFunction;
+		expect(num: number): void;
+
+		//assersions from node assert module
+		fail(actual: any, expected: any, message: string, operator: string): void;
+		assert(value: any, message: string): void;
+		ok(value: any, message?: string): void;
+		equal(actual: any, expected: any, message?: string): void;
+		notEqual(actual: any, expected: any, message?: string): void;
+		deepEqual(actual: any, expected: any, message?: string): void;
+		notDeepEqual(actual: any, expected: any, message?: string): void;
+		strictEqual(actual: any, expected: any, message?: string): void;
+		notStrictEqual(actual: any, expected: any, message?: string): void;
+		throws(block: any, error?: any, message?: string): void;
+		doesNotThrow(block: any, error?: any, message?: string): void;
+		ifError(value: any): void;
+
+		//assertion wrappers
+		equals(actual: any, expected: any, message?: string): void;
+		same(actual: any, expected: any, message?: string): void;
+	}
+
+	// Test Group Usage:
+	//  var testGroup: nodeunit.ITestGroup = {
+	//        setUp: function (callback: nodeunit.ICallbackFunction): void {
+	//            callback();
+	//        },
+	//        tearDown: function (callback: nodeunit.ICallbackFunction): void {
+	//            callback();
+	//        },
+	//        test1: function (test: nodeunit.Test): void {
+	//            test.done();
+	//        }
+	//    }
+	//    exports.testgroup = testGroup;
+
+	export interface ITestBody {
+		(callback: Test): void;
+	}
+
+	export interface ITestGroup {
+		setUp?: (callback: ICallbackFunction) => void;
+		tearDown?: (callback: ICallbackFunction) => void;
+	}
+
+	export interface ICallbackFunction {
+		(err?: any): void;
+	}
+}
+

optimist/optimist-tests.ts

@@ -0,0 +1,46 @@
+/// <reference path="optimist.d.ts" />
+
+import optimist = require('optimist');
+
+var fn: Function;
+var str: string;
+var value: any;
+var num: number;
+var bool: boolean;
+var strArr: string[];
+
+var argv: optimist.Argv;
+var opt: optimist.Optimist;
+
+argv = opt.argv;
+argv = opt.argv;
+argv = optimist(strArr).argv;
+
+opt = optimist(strArr).default(str, value);
+opt = optimist(strArr).default({});
+
+opt = optimist(strArr).boolean(str);
+opt = optimist(strArr).boolean(strArr);
+
+opt = optimist(strArr).string(str);
+opt = optimist(strArr).string(strArr);
+
+opt = opt.wrap(num);
+
+opt.help();
+opt.showHelp(fn);
+
+opt = opt.usage(str);
+
+opt = opt.demand(str);
+opt = opt.demand(num);
+opt = opt.demand(strArr);
+
+opt = opt.alias(str, str);
+
+opt = opt.describe(str, str);
+
+opt = opt.options(str, Object);
+
+opt.check(fn);
+opt = opt.parse(strArr);

optimist/optimist.d.ts

@@ -0,0 +1,53 @@
+// Type definitions for optimist
+// Project: https://github.com/substack/node-optimist
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/optimist.d.ts
+
+declare module "optimist" {
+
+	function optimist(args: string[]): optimist.Optimist;
+
+	module optimist {
+		export interface Optimist {
+			default(name: string, value: any): Optimist;
+			default(args: Object): Optimist;
+
+			boolean(name: string): Optimist;
+			boolean(names: string[]): Optimist;
+
+			string(name: string): Optimist;
+			string(names: string[]): Optimist;
+
+			wrap(columns: number): Optimist;
+
+			help(): void;
+			showHelp(fn: Function): void;
+
+			usage(message: string): Optimist;
+
+			demand(key: string): Optimist;
+			demand(key: number): Optimist;
+			demand(key: string[]): Optimist;
+
+			alias(key: string, alias: string): Optimist;
+
+			describe(key: string, desc: string): Optimist;
+
+			options(key: string, opt: Object): Optimist;
+
+			check(fn: Function): void;
+
+			parse(args: string[]): Optimist;
+
+			argv: Argv;
+		}
+
+		export interface Argv extends Object {
+			_: string[];
+		}
+	}
+
+	export = optimist;
+}

promptly/promptly.d.ts

@@ -6,6 +6,7 @@
 ///<reference path="../node/node.d.ts"/>
 
 declare module "promptly" {
+  import stream = require('stream');
 
   interface Callback {
     (err: Error, value: string): void;
@@ -17,8 +18,8 @@ declare module "promptly" {
     validator?: any;
     retry?: boolean;
     silent?: boolean;
-    input?: ReadableStream;
-    output?: WritableStream;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
   }
 
   export function prompt(message: string, fn?: Callback):any;

q-io/Q-io-tests.ts

@@ -8,7 +8,7 @@ var bool:boolean;
 var num:number;
 var x:any;
 var path:string;
-var buffer:NodeBuffer;
+var buffer:Buffer;
 var str:string;
 var strArr:string[];
 var source:string;
@@ -22,7 +22,7 @@ var anyQ:Q.Promise<any>;
 var strQ:Q.Promise<string>;
 var boolQ:Q.Promise<boolean>;
 var dateQ:Q.Promise<Date>;
-var bufferQ:Q.Promise<NodeBuffer>;
+var bufferQ:Q.Promise<Buffer>;
 
 var statsQ:Q.Promise<QioFS.Stats>;
 var readQ:Q.Promise<Qio.Reader>;
@@ -39,12 +39,12 @@ fs.open(path, options).then((x) => {
 });
 //fs.open(path, options):Q.Promise<Qio.Reader>;
 //fs.open(path, options):Q.Promise<Qio.Writer>;
-//fs.open(path, options):Q.Promise<NodeBuffer>;
+//fs.open(path, options):Q.Promise<Buffer>;
 
 //TODO how to define the multiple return types? use any for now?
 anyQ = fs.read(path, options);
 //strQ = fs.read(path, options);
-//fs.read(path, options):Q.Promise<NodeBuffer>;
+//fs.read(path, options):Q.Promise<Buffer>;
 
 voidQ = fs.write(path, buffer, options);
 voidQ = fs.write(path, str, options);

q-io/Q-io.d.ts

@@ -18,17 +18,17 @@ declare module QioFS {
 	export function open(path:string, options?:any):Q.Promise<any>;
 	//export function open(path:string, options?:any):Q.Promise<Qio.Reader>;
 	//export function open(path:string, options?:any):Q.Promise<Qio.Writer>;
-	//export function open(path:string, options?:any):Q.Promise<NodeBuffer>;
+	//export function open(path:string, options?:any):Q.Promise<Buffer>;
 
 	//TODO how to define the multiple return types? use any for now?
 	export function read(path:string, options?:any):Q.Promise<any>;
 	//export function read(path:string, options?:any):Q.Promise<string>;
-	//export function read(path:string, options?:any):Q.Promise<NodeBuffer>;
+	//export function read(path:string, options?:any):Q.Promise<Buffer>;
 
-	export function write(path:string, content:NodeBuffer, options?:any):Q.Promise<void>;
+	export function write(path:string, content:Buffer, options?:any):Q.Promise<void>;
 	export function write(path:string, content:string, options?:any):Q.Promise<void>;
 
-	export function append(path:string, content:NodeBuffer, options?:any):Q.Promise<void>;
+	export function append(path:string, content:Buffer, options?:any):Q.Promise<void>;
 	export function append(path:string, content:string, options?:any):Q.Promise<void>;
 
 	export function copy(source:string, target:string):Q.Promise<void>;
@@ -102,7 +102,7 @@ declare module QioFS {
 	//this should return a q-io/fs-mock MockFS
 	export function reroot(path:string):typeof QioFS;
 
-	export function toObject(path:string):{[path:string]:NodeBuffer};
+	export function toObject(path:string):{[path:string]:Buffer};
 
 	//listed but not implemented by Q-io
 	//export function glob(pattern):Q.Promise<string[]>;
@@ -189,7 +189,7 @@ declare module QioHTTP {
 
 declare module Qio {
 	interface ForEachCallback {
-		(chunk:NodeBuffer):Q.Promise<any>;
+		(chunk:Buffer):Q.Promise<any>;
 		(chunk:string):Q.Promise<any>;
 	}
 	interface ForEach {
@@ -198,24 +198,24 @@ declare module Qio {
 
 	interface Reader extends ForEach {
 		read(charset:string):Q.Promise<string>;
-		read():Q.Promise<NodeBuffer>;
+		read():Q.Promise<Buffer>;
 		close():void;
-		node:ReadableStream;
+		node: NodeJS.ReadableStream;
 	}
 	interface Writer {
 		write(content:string):void;
-		write(content:NodeBuffer):void;
+		write(content:Buffer):void;
 		flush():Q.Promise<void>;
 		close():void;
 		destroy():void;
-		node:WritableStream;
+		node: NodeJS.WritableStream;
 	}
 
 	interface Stream {
         read(charset:string):Q.Promise<string>;
-        read():Q.Promise<NodeBuffer>;
+        read():Q.Promise<Buffer>;
         write(content:string):void;
-        write(content:NodeBuffer):void;
+        write(content:Buffer):void;
         flush():Q.Promise<void>;
         close():void;
         destroy():void;
@@ -229,15 +229,15 @@ declare module Qio {
 interface QioBufferReader {
 	new ():Qio.Reader;
 	read(stream:Qio.Reader, charset:string):string;
-	read(stream:Qio.Reader):NodeBuffer;
-	join(buffers:NodeBuffer[]):NodeBuffer;
+	read(stream:Qio.Reader):Buffer;
+	join(buffers:Buffer[]):Buffer;
 }
 interface QioBufferWriter {
-	(writer:NodeBuffer):Qio.Writer;
+	(writer:Buffer):Qio.Writer;
 	Writer:Qio.Writer;
 }
 interface QioBufferStream {
-	(buffer:NodeBuffer, encoding:string):Qio.Stream
+	(buffer:Buffer, encoding:string):Qio.Stream
 }
 
 declare module "q-io/http" {

redis/redis-tests.ts

@@ -0,0 +1,62 @@
+/// <reference path="redis.d.ts" />
+
+import redis = require('redis');
+
+var value: any;
+var valueArr: any[];
+var num: number;
+var str: string;
+var bool: boolean;
+var err: Error;
+var args: any[];
+var options: redis.ClientOpts;
+var client: redis.RedisClient;
+var info: redis.ServerInfo;
+var resCallback: (err: Error, res: any) => void;
+var numCallback: (err: Error, res: number) => void;
+var strCallback: (err: Error, res: string) => void;
+var messageHandler: (channel: string, message: any) => void;
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+
+bool = redis.debug_mode;
+redis.print(err, value);
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+
+client = redis.createClient(num, str, options);
+
+bool = client.connected;
+num = client.retry_delay;
+num = client.retry_backoff;
+valueArr = client.command_queue;
+valueArr = client.offline_queue;
+info = client.server_info;
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+
+client.end();
+
+// Connection (http://redis.io/commands#connection)
+client.auth(str, resCallback);
+client.ping(numCallback);
+
+// Strings (http://redis.io/commands#strings)
+client.append(str, str, numCallback);
+client.bitcount(str, numCallback);
+client.bitcount(str, num, num, numCallback);
+client.set(str, str, strCallback);
+client.get(str, strCallback);
+client.exists(str, str, numCallback);
+
+client.publish(str, value);
+client.subscribe(str);
+client.on(str, messageHandler);
+
+// ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ---- ----
+
+// some of the bulk methods
+client.get(args);
+client.get(args, resCallback);
+client.set(args);
+client.set(args, resCallback);

redis/redis.d.ts

@@ -0,0 +1,224 @@
+// Type definitions for redis
+// Project: https://github.com/mranney/node_redis
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/redis.d.ts
+
+declare module "redis" {
+	export function createClient(port_arg: number, host_arg: string, options: ClientOpts): RedisClient;
+	export function print(err: Error, reply: any): void;
+	export var debug_mode: boolean;
+
+	interface MessageHandler {
+		(channel: string, message: any): void;
+	}
+
+	interface ResCallback {
+		(err: Error, res: any): void;
+	}
+
+	interface NumCallback {
+		(err: Error, reply: number): void;
+	}
+
+	interface StringCallback {
+		(err: Error, reply: string): void;
+	}
+
+	interface ServerInfo {
+		redis_version: string;
+		versions: number[];
+	}
+
+	interface ClientOpts {
+		parser: string;
+		return_buffers?: boolean;
+		detect_buffers?: boolean;
+		socket_nodelay?: boolean;
+		no_ready_check?: boolean;
+		enable_offline_queue?: boolean;
+		retry_max_delay?: number;
+		connect_timeout?: number;
+		max_attempts?: number;
+		auth_pass?: boolean;
+	}
+
+	interface RedisClient {
+		// event: connect
+		// event: error
+		// event: message
+		// event: pmessage
+		// event: subscribe
+		// event: psubscribe
+		// event: unsubscribe
+		// event: punsubscribe
+
+		connected: boolean;
+		retry_delay: number;
+		retry_backoff: number;
+		command_queue: any[];
+		offline_queue: any[];
+		server_info: ServerInfo;
+
+		end(): void;
+
+		// Connection (http://redis.io/commands#connection)
+		auth(password: string, callback?: ResCallback): void;
+		ping(callback?: NumCallback): void;
+
+		// Strings (http://redis.io/commands#strings)
+		append(key: string, value: string, callback?: NumCallback): void;
+		bitcount(key: string, callback?: NumCallback): void;
+		bitcount(key: string, start: number, end: number, callback?: NumCallback): void;
+		set(key: string, value: string, callback?: StringCallback): void;
+		get(key: string, callback?: StringCallback): void;
+		exists(key: string, value: string, callback?: NumCallback): void;
+
+		publish(channel: string, value: any): void;
+		subscribe(channel: string): void;
+		on(channel: string, handler: MessageHandler): void;
+
+		/*
+		commands = set_union([
+			"get", "set", "setnx", "setex", "append", "strlen", "del", "exists", "setbit", "getbit", "setrange", "getrange", "substr",
+			"incr", "decr", "mget", "rpush", "lpush", "rpushx", "lpushx", "linsert", "rpop", "lpop", "brpop", "brpoplpush", "blpop", "llen", "lindex",
+			"lset", "lrange", "ltrim", "lrem", "rpoplpush", "sadd", "srem", "smove", "sismember", "scard", "spop", "srandmember", "sinter", "sinterstore",
+			"sunion", "sunionstore", "sdiff", "sdiffstore", "smembers", "zadd", "zincrby", "zrem", "zremrangebyscore", "zremrangebyrank", "zunionstore",
+			"zinterstore", "zrange", "zrangebyscore", "zrevrangebyscore", "zcount", "zrevrange", "zcard", "zscore", "zrank", "zrevrank", "hset", "hsetnx",
+			"hget", "hmset", "hmget", "hincrby", "hdel", "hlen", "hkeys", "hvals", "hgetall", "hexists", "incrby", "decrby", "getset", "mset", "msetnx",
+			"randomkey", "select", "move", "rename", "renamenx", "expire", "expireat", "keys", "dbsize", "auth", "ping", "echo", "save", "bgsave",
+			"bgrewriteaof", "shutdown", "lastsave", "type", "multi", "exec", "discard", "sync", "flushdb", "flushall", "sort", "info", "monitor", "ttl",
+			"persist", "slaveof", "debug", "config", "subscribe", "unsubscribe", "psubscribe", "punsubscribe", "publish", "watch", "unwatch", "cluster",
+			"restore", "migrate", "dump", "object", "client", "eval", "evalsha"], require("./lib/commands"));
+		*/
+
+		get(args: any[], callback?: ResCallback): void;
+		set(args: any[], callback?: ResCallback): void;
+		setnx(args: any[], callback?: ResCallback): void;
+		setex(args: any[], callback?: ResCallback): void;
+		append(args: any[], callback?: ResCallback): void;
+		strlen(args: any[], callback?: ResCallback): void;
+		del(args: any[], callback?: ResCallback): void;
+		exists(args: any[], callback?: ResCallback): void;
+		setbit(args: any[], callback?: ResCallback): void;
+		getbit(args: any[], callback?: ResCallback): void;
+		setrange(args: any[], callback?: ResCallback): void;
+		getrange(args: any[], callback?: ResCallback): void;
+		substr(args: any[], callback?: ResCallback): void;
+		incr(args: any[], callback?: ResCallback): void;
+		decr(args: any[], callback?: ResCallback): void;
+		mget(args: any[], callback?: ResCallback): void;
+		rpush(args: any[], callback?: ResCallback): void;
+		lpush(args: any[], callback?: ResCallback): void;
+		rpushx(args: any[], callback?: ResCallback): void;
+		lpushx(args: any[], callback?: ResCallback): void;
+		linsert(args: any[], callback?: ResCallback): void;
+		rpop(args: any[], callback?: ResCallback): void;
+		lpop(args: any[], callback?: ResCallback): void;
+		brpop(args: any[], callback?: ResCallback): void;
+		brpoplpush(args: any[], callback?: ResCallback): void;
+		blpop(args: any[], callback?: ResCallback): void;
+		llen(args: any[], callback?: ResCallback): void;
+		lindex(args: any[], callback?: ResCallback): void;
+		lset(args: any[], callback?: ResCallback): void;
+		lrange(args: any[], callback?: ResCallback): void;
+		ltrim(args: any[], callback?: ResCallback): void;
+		lrem(args: any[], callback?: ResCallback): void;
+		rpoplpush(args: any[], callback?: ResCallback): void;
+		sadd(args: any[], callback?: ResCallback): void;
+		srem(args: any[], callback?: ResCallback): void;
+		smove(args: any[], callback?: ResCallback): void;
+		sismember(args: any[], callback?: ResCallback): void;
+		scard(args: any[], callback?: ResCallback): void;
+		spop(args: any[], callback?: ResCallback): void;
+		srandmember(args: any[], callback?: ResCallback): void;
+		sinter(args: any[], callback?: ResCallback): void;
+		sinterstore(args: any[], callback?: ResCallback): void;
+		sunion(args: any[], callback?: ResCallback): void;
+		sunionstore(args: any[], callback?: ResCallback): void;
+		sdiff(args: any[], callback?: ResCallback): void;
+		sdiffstore(args: any[], callback?: ResCallback): void;
+		smembers(args: any[], callback?: ResCallback): void;
+		zadd(args: any[], callback?: ResCallback): void;
+		zincrby(args: any[], callback?: ResCallback): void;
+		zrem(args: any[], callback?: ResCallback): void;
+		zremrangebyscore(args: any[], callback?: ResCallback): void;
+		zremrangebyrank(args: any[], callback?: ResCallback): void;
+		zunionstore(args: any[], callback?: ResCallback): void;
+		zinterstore(args: any[], callback?: ResCallback): void;
+		zrange(args: any[], callback?: ResCallback): void;
+		zrangebyscore(args: any[], callback?: ResCallback): void;
+		zrevrangebyscore(args: any[], callback?: ResCallback): void;
+		zcount(args: any[], callback?: ResCallback): void;
+		zrevrange(args: any[], callback?: ResCallback): void;
+		zcard(args: any[], callback?: ResCallback): void;
+		zscore(args: any[], callback?: ResCallback): void;
+		zrank(args: any[], callback?: ResCallback): void;
+		zrevrank(args: any[], callback?: ResCallback): void;
+		hset(args: any[], callback?: ResCallback): void;
+		hsetnx(args: any[], callback?: ResCallback): void;
+		hget(args: any[], callback?: ResCallback): void;
+		hmset(args: any[], callback?: ResCallback): void;
+		hmget(args: any[], callback?: ResCallback): void;
+		hincrby(args: any[], callback?: ResCallback): void;
+		hdel(args: any[], callback?: ResCallback): void;
+		hlen(args: any[], callback?: ResCallback): void;
+		hkeys(args: any[], callback?: ResCallback): void;
+		hvals(args: any[], callback?: ResCallback): void;
+		hgetall(args: any[], callback?: ResCallback): void;
+		hexists(args: any[], callback?: ResCallback): void;
+		incrby(args: any[], callback?: ResCallback): void;
+		decrby(args: any[], callback?: ResCallback): void;
+		getset(args: any[], callback?: ResCallback): void;
+		mset(args: any[], callback?: ResCallback): void;
+		msetnx(args: any[], callback?: ResCallback): void;
+		randomkey(args: any[], callback?: ResCallback): void;
+		select(args: any[], callback?: ResCallback): void;
+		move(args: any[], callback?: ResCallback): void;
+		rename(args: any[], callback?: ResCallback): void;
+		renamenx(args: any[], callback?: ResCallback): void;
+		expire(args: any[], callback?: ResCallback): void;
+		expireat(args: any[], callback?: ResCallback): void;
+		keys(args: any[], callback?: ResCallback): void;
+		dbsize(args: any[], callback?: ResCallback): void;
+		auth(args: any[], callback?: ResCallback): void;
+		ping(args: any[], callback?: ResCallback): void;
+		echo(args: any[], callback?: ResCallback): void;
+		save(args: any[], callback?: ResCallback): void;
+		bgsave(args: any[], callback?: ResCallback): void;
+		bgrewriteaof(args: any[], callback?: ResCallback): void;
+		shutdown(args: any[], callback?: ResCallback): void;
+		lastsave(args: any[], callback?: ResCallback): void;
+		type(args: any[], callback?: ResCallback): void;
+		multi(args: any[], callback?: ResCallback): void;
+		exec(args: any[], callback?: ResCallback): void;
+		discard(args: any[], callback?: ResCallback): void;
+		sync(args: any[], callback?: ResCallback): void;
+		flushdb(args: any[], callback?: ResCallback): void;
+		flushall(args: any[], callback?: ResCallback): void;
+		sort(args: any[], callback?: ResCallback): void;
+		info(args: any[], callback?: ResCallback): void;
+		monitor(args: any[], callback?: ResCallback): void;
+		ttl(args: any[], callback?: ResCallback): void;
+		persist(args: any[], callback?: ResCallback): void;
+		slaveof(args: any[], callback?: ResCallback): void;
+		debug(args: any[], callback?: ResCallback): void;
+		config(args: any[], callback?: ResCallback): void;
+		subscribe(args: any[], callback?: ResCallback): void;
+		unsubscribe(args: any[], callback?: ResCallback): void;
+		psubscribe(args: any[], callback?: ResCallback): void;
+		punsubscribe(args: any[], callback?: ResCallback): void;
+		publish(args: any[], callback?: ResCallback): void;
+		watch(args: any[], callback?: ResCallback): void;
+		unwatch(args: any[], callback?: ResCallback): void;
+		cluster(args: any[], callback?: ResCallback): void;
+		restore(args: any[], callback?: ResCallback): void;
+		migrate(args: any[], callback?: ResCallback): void;
+		dump(args: any[], callback?: ResCallback): void;
+		object(args: any[], callback?: ResCallback): void;
+		client(args: any[], callback?: ResCallback): void;
+		eval(args: any[], callback?: ResCallback): void;
+		evalsha(args: any[], callback?: ResCallback): void;
+	}
+}

request/request-tests.ts

@@ -0,0 +1,198 @@
+/// <reference path="request.d.ts" />
+
+import request = require('request');
+import http = require('http');
+import stream = require('stream');
+import formData = require('form-data');
+
+var value: any;
+var str: string;
+var buffer: NodeBuffer;
+var num: number;
+var bool: boolean;
+var date: Date;
+var obj: Object;
+var dest: string;
+
+var uri: string;
+var headers: {[key: string]: string};
+
+var agent: http.Agent;
+var write: stream.Writable;
+var req: request.Request;
+var form: formData.FormData;
+
+var bodyArr: request.RequestPart[] = [{
+	body: value
+}, {
+	body: value
+}, {
+	body: value
+}];
+
+// --- --- --- --- --- --- --- --- --- --- --- ---
+
+str = req.toJSON();
+
+var cookieValue: request.CookieValue;
+str = cookieValue.name;
+value = cookieValue.value;
+bool = cookieValue.httpOnly;
+
+var cookie: request.Cookie;
+str = cookie.str;
+date = cookie.expires;
+str = cookie.path;
+str = cookie.toString();
+
+var jar: request.CookieJar;
+jar.add(cookie);
+cookie = jar.get(req);
+str = jar.cookieString(req);
+
+var aws: request.AWSOptions;
+str = aws.secret;
+str = aws.bucket;
+
+var oauth: request.OAuthOptions;
+str = oauth.callback;
+str = oauth.consumer_key;
+str = oauth.consumer_secret;
+str = oauth.token;
+str = oauth.token_secret;
+str = oauth.verifier;
+
+var options: request.Options = {
+	url: str,
+	uri: str,
+	callback: (error: any, response: any, body: any) => {
+
+	},
+	jar: value,
+	form: value,
+	oauth: value,
+	aws: aws,
+	qs: obj,
+	json: value,
+	multipart: value,
+	agentOptions: value,
+	agentClass: value,
+	forever: value,
+	host: str,
+	port: num,
+	method: str,
+	headers: value,
+	body: value,
+	followRedirect: bool,
+	followAllRedirects: bool,
+	maxRedirects: num,
+	encoding: str,
+	pool: value,
+	timeout: num,
+	proxy: value,
+	strictSSL: bool
+};
+
+// --- --- --- --- --- --- --- --- --- --- --- ---
+
+agent = req.getAgent();
+//req.start();
+//req.abort();
+req.pipeDest(dest);
+req = req.setHeader(str, str);
+req = req.setHeader(str, str, bool);
+req = req.setHeaders(headers);
+req = req.qs(obj);
+req = req.qs(obj, bool);
+req = req.form(obj);
+form = req.form();
+req = req.multipart(bodyArr);
+req = req.json(value);
+req = req.aws(aws);
+req = req.aws(aws, bool);
+req = req.oauth(oauth);
+req = req.jar(jar);
+write = req.pipe(write);
+write = req.pipe(write, value);
+req.write();
+req.end(str);
+req.end(buffer);
+req.pause();
+req.resume();
+req.abort();
+req.destroy();
+
+// --- --- --- --- --- --- --- --- --- --- --- ---
+
+var callback: (error: any, response: any, body: any) => void;
+
+value = request.initParams;
+
+req = request(uri);
+req = request(uri, options);
+req = request(uri, options, callback);
+req = request(uri, callback);
+req = request(options);
+req = request(options, callback);
+
+req = request.request(uri);
+req = request.request(uri, options);
+req = request.request(uri, options, callback);
+req = request.request(uri, callback);
+req = request.request(options);
+req = request.request(options, callback);
+
+req = request.get(uri);
+req = request.get(uri, options);
+req = request.get(uri, options, callback);
+req = request.get(uri, callback);
+req = request.get(options);
+req = request.get(options, callback);
+
+req = request.post(uri);
+req = request.post(uri, options);
+req = request.post(uri, options, callback);
+req = request.post(uri, callback);
+req = request.post(options);
+req = request.post(options, callback);
+
+req = request.put(uri);
+req = request.put(uri, options);
+req = request.put(uri, options, callback);
+req = request.put(uri, callback);
+req = request.put(options);
+req = request.put(options, callback);
+
+req = request.head(uri);
+req = request.head(uri, options);
+req = request.head(uri, options, callback);
+req = request.head(uri, callback);
+req = request.head(options);
+req = request.head(options, callback);
+
+req = request.patch(uri);
+req = request.patch(uri, options);
+req = request.patch(uri, options, callback);
+req = request.patch(uri, callback);
+req = request.patch(options);
+req = request.patch(options, callback);
+
+req = request.del(uri);
+req = request.del(uri, options);
+req = request.del(uri, options, callback);
+req = request.del(uri, callback);
+req = request.del(options);
+req = request.del(options, callback);
+
+req = request.forever(value, value);
+jar = request.jar();
+cookie = request.cookie(str);
+
+var r = request.defaults(options);
+r(str);
+r.get(str);
+r.post(str);
+
+r(options);
+r.get(options);
+r.post(options);

request/request.d.ts

@@ -0,0 +1,171 @@
+// Type definitions for request
+// Project: https://github.com/mikeal/request
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, bonnici <https://github.com/bonnici>, Bart van der Schoor <https://github.com/Bartvds>
+// Definitions: https://github.com/borisyankov/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 FormData = require('form-data');
+
+	export = RequestAPI;
+
+	function RequestAPI(uri: string, options?: RequestAPI.Options, callback?: (error: any, response: any, body: any) => void): RequestAPI.Request;
+	function RequestAPI(uri: string, callback?: (error: any, response: any, body: any) => void): RequestAPI.Request;
+	function RequestAPI(options: RequestAPI.Options, callback?: (error: any, response: any, body: any) => void): RequestAPI.Request;
+
+	module RequestAPI {
+		export function defaults(options: Options): typeof RequestAPI;
+
+		export function request(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function request(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function request(options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function get(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function get(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function get(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function post(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function post(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function post(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function put(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function put(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function put(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function head(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function head(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function head(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function patch(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function patch(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function patch(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function del(uri: string, options?: Options, callback?: (error: any, response: any, body: any) => void): Request;
+		export function del(uri: string, callback?: (error: any, response: any, body: any) => void): Request;
+		export function del(options: Options, callback?: (error: any, response: any, body: any) => void): Request;
+
+		export function forever(agentOptions: any, optionsArg: any): Request;
+		export function jar(): CookieJar;
+		export function cookie(str: string): Cookie;
+
+		export var initParams: any;
+
+		export interface Options {
+			url?: string;
+			uri?: string;
+			callback?: (error: any, response: any, body: any) => void;
+			jar?: any; // CookieJar
+			form?: FormData;
+			oauth?: OAuthOptions;
+			aws?: AWSOptions;
+			hawk ?: HawkOptions;
+			qs?: Object;
+			json?: any;
+			multipart?: RequestPart[];
+			agentOptions?: any;
+			agentClass?: any;
+			forever?: any;
+			host?: string;
+			port?: number;
+			method?: string;
+			headers?: Headers;
+			body?: any;
+			followRedirect?: boolean;
+			followAllRedirects?: boolean;
+			maxRedirects?: number;
+			encoding?: string;
+			pool?: any;
+			timeout?: number;
+			proxy?: any;
+			strictSSL?: boolean;
+		}
+
+		export interface RequestPart {
+			headers?: Headers;
+			body: any;
+		}
+
+		export interface Request {
+			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.FormData;
+			form(form: any): Request;
+			multipart(multipart: RequestPart[]): Request;
+			json(val: any): Request;
+			aws(opts: AWSOptions, now?: boolean): Request;
+			oauth(oauth: OAuthOptions): Request;
+			jar(jar: CookieJar): Request;
+
+			pipe(dest: stream.Writable, opts?: any): stream.Writable;
+			write(): void;
+			end(chunk: string): void;
+			end(chunk: NodeBuffer): void;
+			pause(): void;
+			resume(): void;
+			abort(): void;
+			destroy(): void;
+			toJSON(): string;
+		}
+
+		export interface Headers {
+			[key: string]: any;
+		}
+
+		export interface AuthOptions {
+			user?: string;
+			username?: string;
+			pass?: string;
+			password?: string;
+			sendImmediately?: boolean;
+		}
+
+		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 {
+			add(cookie: Cookie): void;
+			get(req: Request): Cookie;
+			cookieString(req: Request): string;
+		}
+
+		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;
+		}
+	}
+}

restangular/restangular-tests.ts

@@ -75,7 +75,7 @@ function test_basic() {
 
     $scope.account = account.get({ single: true });
 
-    account.customPOST("messages", { param: "myParam" }, {}, { name: "My Message" })
+    account.customPOST({ name: "My Message" }, "messages", { param: "myParam" }, {})
 }
 
 function test_config() {

restangular/restangular.d.ts

@@ -60,8 +60,8 @@ interface RestangularCustom {
     customGET(path: string, params?: any, headers?: any): ng.IPromise<any>;
     customGETLIST(path: string, params?: any, headers?: any): ng.IPromise<any>;
     customDELETE(path: string, params?: any, headers?: any): ng.IPromise<any>;
-    customPOST(path: string, params?: any, headers?: any, elem?: any): ng.IPromise<any>;
-    customPUT(path: string, params?: any, headers?: any, elem?: any): ng.IPromise<any>;
+    customPOST(elem?: any, path?: string, params?: any, headers?: any): ng.IPromise<any>;
+    customPUT(elem?: any, path?: string, params?: any, headers?: any): ng.IPromise<any>;
     customOperation(operation: string, path: string, params?: any, headers?: any, elem?: any): ng.IPromise<any>;
     addRestangularMethod(name: string, operation: string, path?: string, params?: any, headers?: any, elem?: any): ng.IPromise<any>;
 }

rimraf/rimraf-tests.ts

@@ -0,0 +1,11 @@
+/// <reference path="rimraf.d.ts" />
+
+import rimraf = require('rimraf');
+
+rimraf('./xyz', (err: Error) => {
+
+});
+rimraf.sync('./xyz');
+
+rimraf.EMFILE_MAX = 0;
+rimraf.BUSYTRIES_MAX = 0;

rimraf/rimraf.d.ts

@@ -0,0 +1,16 @@
+// Type definitions for rimraf
+// Project: https://github.com/isaacs/rimraf
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/rimraf.d.ts
+
+declare module "rimraf" {
+	function rimraf(path: string, callback: (error: Error) => void): void;
+	module rimraf {
+		export function sync(path: string): void;
+		export var EMFILE_MAX: number;
+		export var BUSYTRIES_MAX: number;
+	}
+	export = rimraf;
+}

sprintf/sprintf-tests.ts

@@ -0,0 +1,14 @@
+/// <reference path="sprintf.d.ts" />
+
+import sprintf = require('sprintf');
+
+var str: string;
+var num: number;
+
+sprintf.sprintf(str, str);
+sprintf.sprintf(str, str, num);
+sprintf.sprintf(str, num, str);
+
+sprintf.vsprintf(str, [str]);
+sprintf.vsprintf(str, [str, num]);
+sprintf.vsprintf(str, [num, str]);

sprintf/sprintf.d.ts

@@ -0,0 +1,11 @@
+// Type definitions for sprintff
+// Project: https://github.com/maritz/node-sprintff
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/sprintff.d.ts
+
+declare module "sprintf" {
+	export function sprintf(fmt: string, ...args: any[]): string;
+	export function vsprintf(fmt: string, args: any[]): string;
+}

superagent/superagent.d.ts

@@ -6,6 +6,7 @@
 /// <reference path='../node/node.d.ts' />
 
 declare module "superagent" {
+    import stream = require('stream');
   export interface Response {
     text: string;
     body: any;
@@ -43,8 +44,8 @@ declare module "superagent" {
     send(data: string): Request;
     send(data: Object): Request;
     write(data: string, encoding: string): boolean;
-    write(data: NodeBuffer, encoding: string): boolean;
-    pipe(stream: WritableStream, options?: Object): WritableStream;
+    write(data: Buffer, encoding: string): boolean;
+    pipe(stream: NodeJS.WritableStream, options?: Object): stream.Writable;
     buffer(val: boolean): Request;
     timeout(ms: number): Request;
     clearTimeout(): Request;

swig/swig-tests.ts

@@ -0,0 +1,25 @@
+/// <reference path="swig.d.ts" />
+
+import swig = require('swig');
+
+var value: any;
+var str: string;
+var num: number;
+var bool: boolean;
+
+var opts: swig.Options = {
+	allowErrors: bool,
+	autoescape: bool,
+	cache: bool,
+	encoding: str,
+	filters: value,
+	root: str,
+	tags: value,
+	extensions: value,
+	tzOffset: num
+};
+
+swig.init(opts);
+value = swig.compileFile(str);
+value = swig.compile(str);
+value = swig.compile(str, opts);

swig/swig.d.ts

@@ -0,0 +1,24 @@
+// Type definitions for swig
+// Project: http://github.com/paularmstrong/swig
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/swig.d.ts
+
+declare module "swig" {
+	export function init(options: Options): void;
+	export function compileFile(filepath: string): any;
+	export function compile(source: string, options?: Options): any;
+
+	export interface Options {
+		allowErrors?: boolean;
+		autoescape?: boolean;
+		cache?: boolean;
+		encoding?: string;
+		filters?: any;
+		root?: string;
+		tags?: any;
+		extensions?: any;
+		tzOffset?: number;
+	}
+}

swiz/swiz-tests.ts

@@ -0,0 +1,172 @@
+/// <reference path="swiz.d.ts" />
+
+import swiz = require('swiz');
+
+var chain: swiz.IChain;
+var sw: swiz.Swiz;
+var value: any;
+var valueArr: any[];
+var str: string;
+var strArr: string[];
+var exp: RegExp;
+var num: number;
+var bool: boolean;
+var callback: Function;
+
+var defs: swiz.struct.IObj[];
+var opts: swiz.ISwizOptions;
+var field: swiz.struct.IField;
+var ser: swiz.ISerializable;
+var fieldArr: swiz.struct.IField[];
+
+var opts: swiz.ISwizOptions = {
+	stripNulls: bool,
+	stripSerializerType: bool,
+	for: str
+};
+
+var obj: swiz.struct.IObj = {
+	name: str,
+	options: objOpts,
+	singular: str,
+	plural: str,
+	fields: fieldArr
+};
+
+var field: swiz.struct.IField = {
+	name: str,
+	options: fieldOpts,
+	src: str,
+	singular: str,
+	plural: str,
+	desc: str,
+	val: chain,
+	attribute: bool,
+	enumerated: bool,
+	ignorePublic: bool,
+	filterFrom: strArr,
+	coerceTo: value
+};
+
+var objOpts: swiz.struct.IObjOptions = {
+	singular: str,
+	plural: str,
+	fields: fieldArr
+};
+
+var fieldOpts: swiz.struct.IFieldOptions = {
+	src: str,
+	singular: str,
+	plural: str,
+	desc: str,
+	val: chain,
+	attribute: bool,
+	enumerated: value,
+	ignorePublic: bool,
+	filterFrom: strArr,
+	coerceTo: str
+};
+
+var valid: swiz.IValidator;
+str = valid.name;
+valid.func(value, value, callback);
+str = valid.help;
+
+sw = new swiz.Swiz(defs, opts);
+sw.buildObject(value,  (err: any, result: any) => {
+
+});
+value = sw.buildObjectSync(value);
+str = sw.serializeJson(value);
+str = sw.serializeXml(value);
+value = sw.deserializeXml(str);
+sw.serialize(swiz.SERIALIZATION.SERIALIZATION_JSON, num, ser, (err: any, str: string) => {
+
+});
+sw.serializeForPagination(swiz.SERIALIZATION.SERIALIZATION_JSON, valueArr, value, (err: any, str: string) => {
+
+});
+sw.deserialize(swiz.SERIALIZATION.SERIALIZATION_JSON, num, str, (err: any, result: any) => {
+
+});
+field = sw.getFieldDefinition(str, str);
+
+// some of the chain API
+chain = swiz.chain();
+
+num = chain.getValidatorPos(str);
+num = chain.hasValidator(str);
+
+valid = chain.getValidatorAtPos(num);
+chain = chain.isUnique();
+chain = chain.toUnique();
+chain = chain.notIPBlacklisted();
+chain = chain.isCIDR();
+chain = chain.isEmail();
+chain = chain.isUrl();
+chain = chain.isAddressPair();
+chain = chain.isIP();
+chain = chain.isIPv4();
+chain = chain.isIPv6();
+chain = chain.isHostnameOrIp();
+chain = chain.isAllowedFQDNOrIP();
+chain = chain.isAllowedFQDNOrIP(strArr);
+chain = chain.isHostname();
+chain = chain.isAlpha();
+chain = chain.isAlphanumeric();
+chain = chain.isNumeric();
+chain = chain.isInt();
+chain = chain.isLowercase();
+chain = chain.isUppercase();
+chain = chain.isDecimal();
+chain = chain.isFloat();
+chain = chain.notNull();
+chain = chain.isNull();
+chain = chain.notEmpty();
+chain = chain.equals(value);
+chain = chain.contains(value);
+chain = chain.notContains(value);
+chain = chain.notIn(valueArr);
+chain = chain.notIn(valueArr, bool);
+chain = chain.regex(exp);
+chain = chain.regex(str);
+chain = chain.regex(str, str);
+chain = chain.is(str);
+chain = chain.is(str, str);
+chain = chain.notRegex(exp);
+chain = chain.notRegex(str);
+chain = chain.notRegex(str, str);
+chain = chain.not(str, str);
+chain = chain.len(num);
+chain = chain.len(num, num);
+chain = chain.numItems(num, num);
+chain = chain.toFloat();
+chain = chain.toInt();
+chain = chain.toBoolean();
+chain = chain.toBooleanStrict();
+chain = chain.entityDecode();
+chain = chain.entityEncode();
+chain = chain.trim();
+chain = chain.trim(str);
+chain = chain.trim();
+chain = chain.trim(str);
+chain = chain.ltrim();
+chain = chain.ltrim(str);
+chain = chain.rtrim(str);
+chain = chain.ifNull(str);
+chain = chain.xss();
+chain = chain.xss(bool);
+chain = chain.enumerated(value);
+chain = chain.inArray(valueArr);
+chain = chain.isString();
+chain = chain.isBoolean();
+chain = chain.range(value, value);
+chain = chain.optional();
+chain = chain.isPort();
+chain = chain.isV1UUID();
+chain = chain.immutable();
+chain = chain.updateRequired();
+chain = chain.isArray(chain);
+chain = chain.isHash(chain, chain);
+chain = chain.rename(str);
+chain = chain.custom(str);

swiz/swiz.d.ts

@@ -0,0 +1,195 @@
+// Type definitions for swiz
+// Project: https://github.com/racker/node-swiz
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/swiz.d.ts
+
+declare module "swiz" {
+	export class Cidr {
+		constructor(x: string, y?: string);
+		isInCIDR(x: any): boolean;
+	}
+
+	export class Valve {
+		constructor(schema: IValveSchema, baton?: any);
+		setSchema(schema: IValveSchema): Valve;
+		addFinalValidator(func: (obj: any, callback: (err: Error, cleaned: any) => void) => void): Valve;
+		addChainValidator(name: string, description: string, func: (value: any, callback: (err: Error, cleaned: any) => void) => void): void;
+		check(obj: any, options: ICheckOptions, callback: (err: any, cleaned: any) => void): void;
+		check(obj: any, callback: (err: any, cleaned: any) => void): void;
+		checkUpdate(existing: any, obj: any, callback: (err: any, cleaned: any) => void): void;
+		help(schema: IValveSchema): any;
+	}
+
+	export interface ICheckOptions {
+		strict?: boolean;
+	}
+
+	export interface IValveSchema  {
+		[index: string]: IValveSchemaMember;
+	}
+
+	export interface IValveSchemaMember {}
+
+	export interface IValveSchemaMemberArray extends IValveSchemaMember {
+		[index: string]: IValveSchemaMember;
+	}
+
+	export function Chain(): IChain;
+
+	export function chain(): IChain;
+
+	export interface IChain extends IValveSchemaMember {
+		getValidatorPos(name: string): number;
+		hasValidator(name: string): number;
+		getValidatorAtPos(pos: number): IValidator;
+		isUnique(): IChain;
+		toUnique(): IChain;
+		notIPBlacklisted(): IChain;
+		isCIDR(): IChain;
+		isEmail(): IChain;
+		isUrl(): IChain;
+		isAddressPair(): IChain;
+		isIP(): IChain;
+		isIPv4(): IChain;
+		isIPv6(): IChain;
+		isHostnameOrIp(): IChain;
+		isAllowedFQDNOrIP(blacklist?: string[]): IChain;
+		isHostname(): IChain;
+		isAlpha(): IChain;
+		isAlphanumeric(): IChain;
+		isNumeric(): IChain;
+		isInt(): IChain;
+		isLowercase(): IChain;
+		isUppercase(): IChain;
+		isDecimal(): IChain;
+		isFloat(): IChain;
+		notNull(): IChain;
+		isNull(): IChain;
+		notEmpty(): IChain;
+		equals(arg: any): IChain;
+		contains(arg: any): IChain;
+		notContains(arg: any): IChain;
+		notIn(values: any[], caseSensitive?: boolean): IChain;
+		regex(pattern: RegExp): IChain;
+		regex(pattern: string, modifiers?: string): IChain;
+		is(pattern: string, modifiers?: string): IChain;
+		notRegex(pattern: RegExp): IChain;
+		notRegex(pattern: string, modifiers?: string): IChain;
+		not(pattern: string, modifiers: string): IChain;
+		len(min: number, max?: number): IChain;
+		numItems(min: number, max: number): IChain;
+		toFloat(): IChain;
+		toInt(): IChain;
+		toBoolean(): IChain;
+		toBooleanStrict(): IChain;
+		entityDecode(): IChain;
+		entityEncode(): IChain;
+		trim(chars?: string): IChain;
+		ltrim(chars?: string): IChain;
+		rtrim(chars: string): IChain;
+		ifNull(replace: string): IChain;
+		xss(is_image?: boolean): IChain;
+		enumerated(map: any): IChain;
+		inArray(array: any[]): IChain;
+		isString(): IChain;
+		isBoolean(): IChain;
+		range(min: any, max: any): IChain;
+		optional(): IChain;
+		isPort(): IChain;
+		isV1UUID(): IChain;
+		immutable(): IChain;
+		updateRequired(): IChain;
+		isArray(chain: IChain): IChain;
+		isHash(keyChain: IChain, valueChain: IChain): IChain;
+		rename(target: string): IChain;
+		custom(name: string): IChain;
+	}
+
+	export function defToValve(def: struct.IObj[]): IValveSchema[];
+
+	export class Swiz {
+		constructor(defs: struct.IObj[], options?: ISwizOptions);
+		buildObject(obj: any, callback: (err: any, result: any) => void): void;
+		buildObjectSync(obj: any): any;
+		serializeJson(obj: any): string;
+		serializeXml(obj: any): string;
+		deserializeXml(xml: string): any;
+		serialize(mode: SERIALIZATION, version: number, obj: ISerializable, callback: (err: any, result: string) => void): void;
+		serializeForPagination(mode: SERIALIZATION, array: any[], metadata: any, callback: (err: any, result: string) => void): void;
+		deserialize(mode: SERIALIZATION, version: number, raw: string, callback: (err: any, result: any) => void): void;
+		getFieldDefinition(stype: string, name: string): struct.IField;
+	}
+
+	export interface ISerializable {
+		getSerializerType(): string;
+	}
+
+	export interface ISwizOptions {
+		stripNulls?: boolean;
+		stripSerializerType?: boolean;
+		for?: string;
+	}
+
+	interface IValidator {
+		name: string;
+		func(value: any, baton: any, callback: Function): void;
+		help: string;
+	}
+
+	export function stripSerializerTypes(obj: any): any;
+
+	export module struct {
+		export function Obj(name: string, options?: IObjOptions): IObj;
+		export function Field(name: string, options?: IFieldOptions): IField;
+		export function coerce(value: any, coerceTo: string): any;
+
+		export interface IObj {
+			name: string;
+			options: IObjOptions;
+			singular: string;
+			plural: string;
+			fields: IField[];
+		}
+
+		export interface IField {
+			name: string;
+			options: IFieldOptions;
+			src: string;
+			singular: string;
+			plural: string;
+			desc?: string;
+			val?: IChain;
+			attribute: boolean;
+			enumerated: boolean;
+			ignorePublic: boolean;
+			filterFrom: string[];
+			coerceTo: any;
+		}
+
+		export interface IObjOptions {
+			singular?: string;
+			plural?: string;
+			fields?: IField[];
+		}
+
+		export interface IFieldOptions {
+			src?: string;
+			singular?: string;
+			plural?: string;
+			desc?: string;
+			val?: IChain;
+			attribute?: boolean;
+			enumerated?: any;
+			ignorePublic?: boolean;
+			filterFrom?: string[];
+			coerceTo?: string;
+		}
+	}
+
+	export enum SERIALIZATION {
+		SERIALIZATION_JSON,
+		SERIALIZATION_XML
+	}
+}

threejs/three-tests.ts

@@ -10550,7 +10550,6 @@ var container, stats;
         }
 
         geometry.computeFaceNormals();
-        geometry.computeCentroids();
 
         group = new THREE.Object3D();
         group.scale.x = group.scale.y = group.scale.z = 2;
@@ -16481,13 +16480,13 @@ function render() {
                 var normalLength = 15;
 
                 var fl: number;
-                var face: THREE.Face;
+                var face: THREE.Face3;
 
                 for( f = 0, fl = geometry.faces.length; f < fl; f ++ ) {
                     face = geometry.faces[ f ];
                     var arrow = new THREE.ArrowHelper( 
                             face.normal,
-                            face.centroid,
+                            face.normal,
                             normalLength,
                             0x3333FF );
                     mesh.add( arrow );
@@ -17321,7 +17320,6 @@ function render() {
                 // mergeVertices(); is run in case of duplicated vertices
                 smooth.mergeVertices();
 
-                smooth.computeCentroids();
                 smooth.computeFaceNormals();
                 smooth.computeVertexNormals();
 

through/through.d.ts

@@ -6,7 +6,7 @@
 /// <reference path="../node/node.d.ts" />
 
 declare module "through" {
-	import Stream = require("stream");
+	import stream = require("stream");
 
 	function through(write?: (data) => void,
 		end?: () => void,
@@ -15,7 +15,7 @@ declare module "through" {
 		}): through.ThroughStream;
 
 	module through {
-		export interface ThroughStream extends ReadWriteStream {
+		export interface ThroughStream extends stream.Transform {
 			autoDestroy: boolean;
 		}
 	}

timezone-js/timezone-js-tests.ts

@@ -0,0 +1,26 @@
+/// <reference path="timezone-js.d.ts" />
+
+import timezone = require('timezone-js');
+var tz = timezone.timezone;
+
+var value: any;
+var str: string;
+var bool: boolean;
+
+var opts: timezone.TimezoneJsOptions = {
+	async: bool,
+	success: (data: string) => {
+
+	},
+	error: (err: Error) => {
+
+	},
+	url: str
+};
+
+str = tz.zoneFileBasePath;
+tz.loadingScheme;
+tz.loadingSchemes;
+
+value = tz.transport(opts);
+value = tz.init(opts);

timezone-js/timezone-js.d.ts

@@ -0,0 +1,45 @@
+// Type definitions for timezone-js
+// Project: https://github.com/mde/timezone-js
+// Definitions by: bonnici <https://github.com/bonnici>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/timezone-js.d.ts
+
+declare module "timezone-js" {
+	export var timezone: TimezoneJs;
+
+	export var Date: {
+		new (timezone?: string): TimezoneJsDate;
+		new (time: string, timezone?: string): TimezoneJsDate;
+		new (year?: number, month?: number, day?: number, hour?: number, minute?: number, second?: string, timezone?: string): TimezoneJsDate;
+	};
+
+	export interface TimezoneJsDate extends Date {
+		setTimezone: (timezone: string) => void;
+	}
+
+	export interface TimezoneJs {
+		zoneFileBasePath: string;
+		loadingScheme: TimezoneJsLoadingScheme;
+		loadingSchemes: TimezoneJsLoadingSchemes;
+
+		transport(opts: TimezoneJsOptions): any;
+		init(opts?: TimezoneJsOptions): any;
+	}
+
+	export interface TimezoneJsOptions {
+		async?: boolean;
+		success?: (data: string) => void;
+		error?: (err: Error) => void;
+		url?: string;
+	}
+
+	export interface TimezoneJsLoadingScheme {
+	}
+
+	export enum TimezoneJsLoadingSchemes {
+		PRELOAD_ALL,
+		LAZY_LOAD,
+		MANUAL_LOAD
+	}
+ }

twig/twig-tests.ts

@@ -0,0 +1,45 @@
+/// <reference path="twig.d.ts" />
+
+import twig = require('twig');
+
+var value: any;
+var str: string;
+var num: number;
+var bool: boolean;
+
+var params: twig.Parameters = {
+	id: value,
+	ref: value,
+	href: value,
+	path: value,
+	debug: bool,
+	trace: bool,
+	strict_variables: bool,
+	data: value
+};
+
+var temp: twig.Template;
+var compOpts: twig.CompileOptions = {
+	filename: str,
+	settings: value
+};
+
+var compiled:(context: any) => any;
+
+temp = twig.twig(params);
+twig.extendFilter(str, (left: any, ...params: any[]) => {
+	return str;
+});
+twig.extendFunction(str, (...params: any[]) => {
+	return str;
+});
+twig.extendTest(str, (value: any) => bool);
+twig.extendTag(value);
+compiled = twig.compile(str, compOpts);
+twig.renderFile(str, compOpts, (err, result) => {
+
+});
+twig.__express(str, compOpts, (err, result) => {
+
+});
+twig.cache(bool);

twig/twig.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for twig
+// Project: https://github.com/justjohn/twig.js
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/twig.d.ts
+
+declare module "twig" {
+	export interface Parameters {
+		id?: any;
+		ref?: any;
+		href?: any;
+		path?: any;
+		debug?: boolean;
+		trace?: boolean;
+		strict_variables?: boolean;
+		data: any;
+	}
+
+	export interface Template {
+	}
+
+	export interface CompileOptions {
+		filename: string;
+		settings: any;
+	}
+
+	export function twig(params: Parameters): Template;
+	export function extendFilter(name: string, definition: (left: any, ...params: any[]) => string): void;
+	export function extendFunction(name: string, definition: (...params: any[]) => string): void;
+	export function extendTest(name: string, definition: (value: any) => boolean): void;
+	export function extendTag(definition: any): void;
+	export function compile(markup: string, options: CompileOptions): (context: any) => any;
+	export function renderFile(path: string, options: CompileOptions, fn: (err: Error, result: any) => void): void;
+	export function __express(path: string, options: CompileOptions, fn: (err: Error, result: any) => void): void;
+	export function cache(value: boolean): void;
+}

underscore.string/underscore.string.d.ts

@@ -562,7 +562,8 @@ interface UnderscoreStringStaticExports {
     toBoolean(str: string, trueValues?: any[], falseValues?: any[]): boolean;
 
 }
-declare module "underscore.string" {
-export = UnderscoreStringStatic;
+declare module 'underscore.string' {
+    var underscoreString: UnderscoreStringStatic;
+    export = underscoreString;
 }
 // TODO interface UnderscoreString extends Underscore<string>

watch/watch-tests.ts

@@ -0,0 +1,32 @@
+/// <reference path="watch.d.ts" />
+
+import watch = require('watch');
+import fs = require('fs');
+
+var value: any;
+var str: string;
+var num: number;
+var bool: boolean;
+
+var mon: watch.Monitor;
+var opts: watch.Options = {
+	ignoreDotFiles: bool,
+	filter: value
+};
+
+mon.on('foo', () => {
+
+});
+
+watch.watchTree(str, (f: any, curr: fs.Stats, prev: fs.Stats) => {
+
+});
+watch.watchTree(str, opts, (f: any, curr: fs.Stats, prev: fs.Stats) => {
+
+});
+watch.createMonitor(str, (monitor: watch.Monitor) => {
+
+});
+watch.createMonitor(str, opts, (monitor: watch.Monitor) => {
+
+});

watch/watch.d.ts

@@ -0,0 +1,35 @@
+// Type definitions for watch
+// Project: https://github.com/mikeal/watch
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/watch.d.ts
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "watch" {
+	import fs = require("fs");
+	import events = require("events");
+
+	export interface Monitor extends events.EventEmitter {
+		// event: created
+		// event: removed
+		// event: changed
+
+		// export function onCreated(callback, function(f, stat: fs.Stats) { });
+		// export function onChanged(callback, function(f, curr: fs.Stats, prev: fs.Stats) { });
+		// export function onRemoved(callback, function(f, stat: fs.Stats) { });
+	}
+
+	export interface Options {
+		persistent?: boolean;
+		ignoreDotFiles?: boolean;
+		filter?: any;
+		interval?: number;
+	}
+
+	export function watchTree(root: string, callback: (f: any, curr: fs.Stats, prev: fs.Stats) => void): void;
+	export function watchTree(root: string, options: Options, callback: (f: any, curr: fs.Stats, prev: fs.Stats) => void): void;
+	export function createMonitor(root: string, callback: (monitor: Monitor) => void): void;
+	export function createMonitor(root: string, options: Options, callback: (monitor: Monitor) => void): void;
+}

websocket/websocket.d.ts

@@ -128,11 +128,11 @@ declare module "websocket" {
         constructor(serverConfig?: IServerConfig);
 
         /** Send binary message for each connection */
-        broadcast(data: NodeBuffer): void;
+        broadcast(data: Buffer): void;
         /** Send UTF-8 message for each connection */
         broadcast(data: IStringified): void;
         /** Send binary message for each connection */
-        broadcastBytes(data: NodeBuffer): void;
+        broadcastBytes(data: Buffer): void;
         /** Send UTF-8 message for each connection */
         broadcastUTF(data: IStringified): void;
         /** Attach the `server` instance to a Node http.Server instance */
@@ -251,26 +251,26 @@ declare module "websocket" {
     export interface IMessage {
         type: string;
         utf8Data?: string;
-        binaryData?: NodeBuffer;
+        binaryData?: Buffer;
     }
 
     export interface IBufferList extends events.EventEmitter {
         encoding: string;
         length: number;
-        write(buf: NodeBuffer): boolean;
-        end(buf: NodeBuffer): void;
+        write(buf: Buffer): boolean;
+        end(buf: Buffer): void;
 
         /**
          * For each buffer, perform some action.
          * If fn's result is a true value, cut out early.
          */
-        forEach(fn: (buf: NodeBuffer) => boolean): void;
+        forEach(fn: (buf: Buffer) => boolean): void;
 
         /** Create a single buffer out of all the chunks */
-        join(start: number, end: number): NodeBuffer;
+        join(start: number, end: number): Buffer;
 
         /** Join all the chunks to existing buffer */
-        joinInto(buf: NodeBuffer, offset: number, start: number, end: number): NodeBuffer;
+        joinInto(buf: Buffer, offset: number, start: number, end: number): Buffer;
 
         /**
          * Advance the buffer stream by `n` bytes.
@@ -290,10 +290,10 @@ declare module "websocket" {
         // Events
         on(event: string, listener: () => void): IBufferList;
         on(event: 'advance', cb: (n: number) => void): IBufferList;
-        on(event: 'write', cb: (buf: NodeBuffer) => void): IBufferList;
+        on(event: 'write', cb: (buf: Buffer) => void): IBufferList;
         addListener(event: string, listener: () => void): IBufferList;
         addListener(event: 'advance', cb: (n: number) => void): IBufferList;
-        addListener(event: 'write', cb: (buf: NodeBuffer) => void): IBufferList;
+        addListener(event: 'write', cb: (buf: Buffer) => void): IBufferList;
     }
 
     class connection extends events.EventEmitter {
@@ -330,8 +330,8 @@ declare module "websocket" {
         config: IConfig;
         socket: net.Socket;
         maskOutgoingPackets: boolean;
-        maskBytes: NodeBuffer;
-        frameHeader: NodeBuffer;
+        maskBytes: Buffer;
+        frameHeader: Buffer;
         bufferList: IBufferList;
         currentFrame: frame;
         fragmentationSize: number;
@@ -390,14 +390,14 @@ declare module "websocket" {
          * to the remote peer. If config.fragmentOutgoingMessages is true the message may be
          * sent as multiple fragments if it exceeds config.fragmentationThreshold bytes.
          */
-        sendBytes(buffer: NodeBuffer): void;
+        sendBytes(buffer: Buffer): void;
 
         /** Auto-detect the data type and send UTF-8 or Binary message */
-        send(data: NodeBuffer): void;
+        send(data: Buffer): void;
         send(data: IStringified): void;
 
         /** Sends a ping frame. Ping frames must not exceed 125 bytes in length. */
-        ping(data: NodeBuffer): void;
+        ping(data: Buffer): void;
         ping(data: IStringified): void;
 
         /**
@@ -408,7 +408,7 @@ declare module "websocket" {
          * be no need to use this method to respond to pings.
          * Pong frames must not exceed 125 bytes in length.
          */
-        pong(buffer: NodeBuffer): void;
+        pong(buffer: Buffer): void;
 
         /**
          * Serializes a `frame` object into binary data and immediately sends it to
@@ -494,10 +494,10 @@ declare module "websocket" {
          * The binary payload data.
          * Even text frames are sent with a Buffer providing the binary payload data.
          */
-        binaryPayload: NodeBuffer;
+        binaryPayload: Buffer;
 
-        maskBytes: NodeBuffer;
-        frameHeader: NodeBuffer;
+        maskBytes: Buffer;
+        frameHeader: Buffer;
         config: IConfig;
         maxReceivedFrameSize: number;
         protocolError: boolean;
@@ -507,7 +507,7 @@ declare module "websocket" {
 
         addData(bufferList: IBufferList): boolean;
         throwAwayPayload(bufferList: IBufferList): boolean;
-        toBuffer(nullMask: boolean): NodeBuffer;
+        toBuffer(nullMask: boolean): Buffer;
     }
 
     export interface IClientConfig extends IConfig {

winston/winston-tests.ts

@@ -0,0 +1,40 @@
+/// <reference path="winston.d.ts" />
+
+import winston = require('winston');
+
+var str: string;
+var bool: boolean;
+var metadata: any;
+var options: any;
+var value: any;
+var transport: winston.Transport;
+
+transport = winston.transports.File;
+transport = winston.transports.Console;
+transport = winston.transports.Loggly;
+
+winston.log(str, str);
+winston.log(str, str, metadata);
+winston.debug(str);
+winston.debug(str, metadata);
+winston.info(str);
+winston.info(str, metadata);
+winston.warn(str);
+winston.warn(str, metadata);
+winston.error(str);
+winston.error(str, metadata);
+
+winston.add(transport, options);
+winston.remove(transport);
+
+winston.profile(str);
+
+winston.query(options, (err: any, results: any) => {
+
+});
+
+value = winston.stream(options);
+
+winston.handleExceptions(transport);
+winston.exitOnError = bool;
+

winston/winston.d.ts

@@ -0,0 +1,39 @@
+// Type definitions for winston
+// Project: https://github.com/flatiron/winston
+// Definitions by: bonnici <https://github.com/bonnici>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/winston.d.ts
+
+declare module "winston" {
+	export function log(level: string, message: string, metadata?: any): void;
+	export function debug(message: string, metadata?: any): void;
+	export function info(message: string, metadata?: any): void;
+	export function warn(message: string, metadata?: any): void;
+	export function error(message: string, metadata?: any): void;
+
+	export function add(transport: Transport, options: any): void;
+	export function remove(transport: Transport): void;
+
+	export function profile(name: string): void;
+
+	export function query(options: any, done: (err: any, results: any) => void): void;
+
+	export function stream(options: any): any;
+
+	export function handleExceptions(transport: Transport): void;
+
+	export class Logger {
+
+	}
+
+	export interface Transport {
+	}
+	export interface Transports {
+		File: Transport;
+		Console: Transport;
+		Loggly: Transport;
+	}
+	export var transports: Transports;
+	export var exitOnError: boolean;
+}

wrench/wrench-tests.ts

@@ -0,0 +1,36 @@
+/// <reference path="wrench.d.ts" />
+
+import wrench = require('wrench');
+
+var str: string;
+var num: number;
+var bool: boolean;
+var strArr: string[];
+var line: wrench.LineReader;
+
+strArr = wrench.readdirSyncRecursive(str);
+wrench.rmdirSyncRecursive(str);
+wrench.rmdirSyncRecursive(str, bool);
+wrench.copyDirSyncRecursive(str, str);
+wrench.copyDirSyncRecursive(str, str, {
+	preserve: bool
+});
+wrench.chmodSyncRecursive(str, num);
+wrench.chownSyncRecursive(str, num, num);
+wrench.mkdirSyncRecursivefunction(str, num);
+wrench.readdirRecursive(str, (err: Error, files: string[]) => {
+
+});
+wrench.rmdirRecursive(str, (err: Error) => {
+
+});
+wrench.copyDirRecursive(str, str, (err: Error) => {
+
+});
+
+line = new wrench.LineReader(str);
+line = new wrench.LineReader(str, num);
+
+str = line.getNextLine();
+bool = line.hasNextLine();
+num = line.getBufferAndSetCurrentPosition(num);

wrench/wrench.d.ts

@@ -0,0 +1,27 @@
+// Type definitions for wrench
+// Project: https://github.com/ryanmcgrath/wrench-js
+// Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/wrench.d.ts
+
+declare module "wrench" {
+	export function readdirSyncRecursive(baseDir: string): string[];
+	export function rmdirSyncRecursive(path: string, failSilent?: boolean): void;
+	export function copyDirSyncRecursive(sourceDir: string, newDirLocation: string, opts?: { preserve?: boolean; }): void;
+	export function chmodSyncRecursive(sourceDir: string, filemode: number): void;
+	export function chownSyncRecursive(sourceDir: string, uid: number, gid: number): void;
+	export function mkdirSyncRecursivefunction(path: string, mode: number): void;
+
+	export function readdirRecursive(baseDir: string, fn: (err: Error, files: string[]) => void): void;
+	export function rmdirRecursive(path: string, fn: (err: Error) => void): void;
+	export function copyDirRecursive(srcDir: string, newDir: string, fn: (err: Error) => void): void;
+
+	export class LineReader {
+		constructor (filename: string, bufferSize?: number);
+
+		getBufferAndSetCurrentPosition(position: number): number;
+		hasNextLine(): boolean;
+		getNextLine(): string;
+	}
+}

ws/ws.d.ts

@@ -110,7 +110,7 @@ declare module "ws" {
 
             close(): void;
             handleUpgrade(request: http.ClientRequest, socket: net.Socket,
-                          upgradeHead: NodeBuffer, callback: (client: WebSocket) => void): void;
+                          upgradeHead: Buffer, callback: (client: WebSocket) => void): void;
 
             // Events
             on(event: string, listener: () => void): Server;