Resolve conflicts

.gitattributes

@@ -1,22 +1,2 @@
 # Auto detect text files and perform LF normalization
 * text=auto
-
-# Custom for Visual Studio
-*.cs     diff=csharp
-*.sln    merge=union
-*.csproj merge=union
-*.vbproj merge=union
-*.fsproj merge=union
-*.dbproj merge=union
-
-# Standard to msysgit
-*.doc	 diff=astextplain
-*.DOC	 diff=astextplain
-*.docx diff=astextplain
-*.DOCX diff=astextplain
-*.dot  diff=astextplain
-*.DOT  diff=astextplain
-*.pdf  diff=astextplain
-*.PDF	 diff=astextplain
-*.rtf	 diff=astextplain
-*.RTF	 diff=astextplain

.travis.yml

@@ -1,6 +1,6 @@
 language: node_js
 node_js:
-  - 6.9.2
+  - node
 
 sudo: false
 

CONTRIBUTING.md

@@ -1 +0,0 @@
-Please see the [contribution guide](http://definitelytyped.org/guides/contributing.html) at [definitelytyped.org](http://definitelytyped.org/guides/contributing.html) for information on how to contribute to DefinitelyTyped.

acorn/acorn-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="estree" />
-
 import acorn = require('acorn');
 import * as ESTree from 'estree';
 

amplify/amplify-tests.ts

@@ -1,6 +1,3 @@
-
-/// <reference types="jquery" />
-
 import amplify = require("amplify");
 
 // Copied examples directly from AmplifyJs site

angular-bootstrap-calendar/angular-bootstrap-calendar-tests.ts

@@ -1,6 +1,3 @@
-///<reference path='index.d.ts'/>
-///<reference types="angular"/>
-
 var myApp = angular.module('testModule');
 
 interface MyAppScope extends ng.IScope {

angular-feature-flags/angular-feature-flags-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="angular" />
-
 import * as angular from "angular";
 
 let myApp = angular.module('myApp', ['feature-flags']);

angular-hotkeys/angular-hotkeys-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="angular" />
-
 var scope: ng.IScope;
 var hotkeyProvider: ng.hotkeys.HotkeysProvider;
 var hotkeyObj: ng.hotkeys.Hotkey;

angular-jwt/angular-jwt-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="angular" />
-
 var app = angular.module("angular-jwt-tests", ["angular-jwt"]);
 
 var $jwtHelper: ng.jwt.IJwtHelper;

angular-material/index.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for Angular Material (angular.material module) 1.1
 // Project: https://github.com/angular/material
-// Definitions by: Blake Bigelow <https://github.com/blbigelow>, Peter Hajdu <https://github.com/PeterHajdu>, Davide Donadello <https://github.com/Dona278>
+// Definitions by: Blake Bigelow <https://github.com/blbigelow>, Peter Hajdu <https://github.com/PeterHajdu>, Davide Donadello <https://github.com/Dona278>, Geert Jansen <https://github.com/geertjansen>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 import * as angular from 'angular';
@@ -18,6 +18,7 @@ declare module 'angular' {
             controller?: string | Function;
             locals?: { [index: string]: any };
             clickOutsideToClose?: boolean;
+            bindToController?: boolean; // default: false
             disableBackdrop?: boolean;
             escapeToClose?: boolean;
             resolve?: { [index: string]: () => angular.IPromise<any> };

angular-modal/angular-modal-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery" />
-
 var btfModal: angularModal.AngularModalFactory;
 
 // Using template URL

angular-oauth2/angular-oauth2-tests.ts

@@ -1,7 +1,7 @@
 import * as angular from 'angular';
 
 angular.module('angular-oauth2-test', ['angular-oauth2'])
-       .config(['OAuthProvider', function(OAuthProvider:angular.oauth2.OAuthProvider){
+       .config(['OAuthProvider', (OAuthProvider: angular.oauth2.OAuthProvider) => {
             OAuthProvider.configure({
                 baseUrl: 'https://api.website.com',
                 clientId: 'CLIENT_ID',

angular-oauth2/tsconfig.json

@@ -2,6 +2,10 @@
     "compilerOptions": {
         "module": "commonjs",
         "target": "es6",
+        "lib": [
+            "es6",
+            "dom"
+        ],
         "noImplicitAny": true,
         "noImplicitThis": true,
         "strictNullChecks": true,

angular-ui-bootstrap/index.d.ts

@@ -15,6 +15,7 @@ export type IDropdownConfig = angular.ui.bootstrap.IDropdownConfig;
 export type IModalProvider = angular.ui.bootstrap.IModalProvider;
 export type IModalService = angular.ui.bootstrap.IModalService;
 export type IModalServiceInstance = angular.ui.bootstrap.IModalServiceInstance;
+export type IModalInstanceService = angular.ui.bootstrap.IModalInstanceService;
 export type IModalScope = angular.ui.bootstrap.IModalScope;
 export type IModalSettings = angular.ui.bootstrap.IModalSettings;
 export type IModalStackService = angular.ui.bootstrap.IModalStackService;
@@ -320,12 +321,12 @@ declare module 'angular' {
         interface IModalService {
             /**
              * @param {IModalSettings} options
-             * @returns {IModalServiceInstance}
+             * @returns {IModalInstanceService}
              */
-            open(options: IModalSettings): IModalServiceInstance;
+            open(options: IModalSettings): IModalInstanceService;
         }
 
-        interface IModalServiceInstance {
+        interface IModalInstanceService {
             /**
              * A method that can be used to close a modal, passing a result. If `preventDefault` is called on the `modal.closing` event then the modal will remain open.
              */
@@ -357,6 +358,11 @@ declare module 'angular' {
             closed: angular.IPromise<any>;
         }
 
+        /**
+         * @deprecated use IModalInstanceService instead.
+         */
+        interface IModalServiceInstance extends IModalInstanceService { }
+
         interface IModalScope extends angular.IScope {
             /**
              * Dismiss the dialog without assigning a value to the promise output. If `preventDefault` is called on the `modal.closing` event then the modal will remain open.
@@ -512,17 +518,17 @@ declare module 'angular' {
             /**
              * Opens a new modal instance.
              */
-            open(modalInstance: IModalServiceInstance, modal: any): void;
+            open(modalInstance: IModalInstanceService, modal: any): void;
 
             /**
              * Closes a modal instance with an optional result.
              */
-            close(modalInstance: IModalServiceInstance, result?: any): void;
+            close(modalInstance: IModalInstanceService, result?: any): void;
 
             /**
              * Dismisses a modal instance with an optional reason.
              */
-            dismiss(modalInstance: IModalServiceInstance, reason?: any): void;
+            dismiss(modalInstance: IModalInstanceService, reason?: any): void;
 
             /**
              * Dismiss all open modal instances with an optional reason that will be passed to each instance.
@@ -536,7 +542,7 @@ declare module 'angular' {
         }
 
         interface IModalStackedMapKeyValuePair {
-            key: IModalServiceInstance;
+            key: IModalInstanceService;
             value: any;
         }
 

angular/index.d.ts

@@ -1332,9 +1332,19 @@ declare namespace angular {
     // see http://docs.angularjs.org/api/ng.$controller
     // see http://docs.angularjs.org/api/ng.$controllerProvider
     ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * The minimal local definitions required by $controller(ctrl, locals) calls.
+     */
+    interface IControllerLocals {
+        $scope: ng.IScope;
+        $element: JQuery;
+    }
+
     interface IControllerService {
         // Although the documentation doesn't state this, locals are optional
         <T>(controllerConstructor: new (...args: any[]) => T, locals?: any, later?: boolean, ident?: string): T;
+        <T>(controllerConstructor: Function, locals?: IControllerLocals, later?: boolean, ident?: string): T;
         <T>(controllerConstructor: Function, locals?: any, later?: boolean, ident?: string): T;
         <T>(controllerName: string, locals?: any, later?: boolean, ident?: string): T;
     }

archiver/archiver-tests.ts

@@ -1,6 +1,3 @@
-
-/// <reference types="node" />
-
 import Archiver = require('archiver');
 import FS = require('fs');
 

async/index.d.ts

@@ -6,17 +6,16 @@
 interface Dictionary<T> { [key: string]: T; }
 
 interface ErrorCallback<T> { (err?: T): void; }
-interface AsyncWaterfallCallback<E> { (err: E, ...args: any[]): void; }
-interface AsyncBooleanResultCallback<E> { (err: E, truthValue: boolean): void; }
-interface AsyncResultCallback<T, E> { (err: E, result: T): void; }
-interface AsyncResultArrayCallback<T, E> { (err: E, results: T[]): void; }
-interface AsyncResultObjectCallback<T, E> { (err: E, results: Dictionary<T>): void; }
+interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
+interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
+interface AsyncResultArrayCallback<T, E> { (err?: E, results?: (T | undefined)[]): void; }
+interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
 interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
 interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
 interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
 interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-interface AsyncMemoIterator<T, R, E> { (memo: R, item: T, callback: AsyncResultCallback<R, E>): void; }
+interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
 interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
 interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
@@ -76,7 +75,7 @@ interface AsyncPriorityQueue<T> {
 
 interface AsyncCargo {
     length(): number;
-    payload: number;
+    payload?: number;
     push(task: any, callback? : Function): void;
     push(task: any[], callback? : Function): void;
     saturated(): void;
@@ -175,7 +174,7 @@ interface Async {
     during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
     doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
     forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
-    waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T,E>): void;
+    waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
     compose(...fns: Function[]): Function;
     seq(...fns: Function[]): Function;
     applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
@@ -186,29 +185,30 @@ interface Async {
     cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
     auto<E>(tasks: any, concurrency?: number, callback?: AsyncResultCallback<any, E>): void;
     autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
-    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
-    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
-    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E>;
+    retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+    retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
+    retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
+    apply<E>(fn: Function, ...arguments: any[]): AsyncFunction<any,E | Error>;
     nextTick(callback: Function, ...args: any[]): void;
     setImmediate: typeof async.nextTick;
 
-    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: void, result: {error?: Error, value?: T}) => void) => void;
-    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: void, result: {error?: Error, value?: T}) => void) => void)[];
+    reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+    reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
 
-    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
-    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
+    timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
+    timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
 
     times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
     timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
     timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
-    transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
-    transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void): void;
+    transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+    transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
+    transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+    transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+
+    race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
 
     // Utils
     memoize(fn: Function, hasher?: Function): Function;
@@ -226,4 +226,3 @@ declare var async: Async;
 declare module "async" {
     export = async;
 }
-

async/test/explicit.ts

@@ -1,44 +1,74 @@
 
 
-interface StringCallback { (err: Error, result: string): void; }
+interface StringCallback { (err?: Error, result?: string): void; }
 interface AsyncStringGetter { (callback: StringCallback): void; }
 
 var taskArray: AsyncStringGetter[] = [
     function (callback) {
         setTimeout(function () {
-            callback(null, 'one');
+            callback(undefined, 'one');
         }, 200);
     },
     function (callback) {
         setTimeout(function () {
-            callback(null, 'two');
+            callback(undefined, 'two');
         }, 100);
     },
 ];
 
-async.series(taskArray, function (err, results) { console.log(results[0].match(/o/)) });
-async.parallel(taskArray, function (err, results) { console.log(results[0].match(/o/)) });
-async.parallelLimit(taskArray, 3, function (err, results) { console.log(results[0].match(/o/)) });
+async.series(taskArray, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
+async.parallel(taskArray, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
+async.parallelLimit(taskArray, 3, function (err, results) {
+    if (results) {
+        let first = results[0];
+        if (first) {
+            console.log(first.match(/o/))
+        }
+    }
+});
 
 
 interface Lookup<T> { [key: string]: T; }
-interface NumberCallback { (err: Error, result: number): void; }
+interface NumberCallback { (err?: Error, result?: number): void; }
 interface AsyncNumberGetter { (callback: NumberCallback): void; }
 
 var taskDict: Lookup<AsyncNumberGetter> = {
     one: function(callback){
         setTimeout(function(){
-            callback(null, 1);
+            callback(undefined, 1);
         }, 200);
     },
     two: function(callback){
         setTimeout(function(){
-            callback(null, 2);
+            callback(undefined, 2);
         }, 100);
     }
 }
 
-async.series(taskDict, function(err, results) { console.log(results['one'].toFixed(1)) });
-async.parallel(taskDict, function(err, results) { console.log(results['one'].toFixed(1)) });
-async.parallelLimit(taskDict, 3, function(err, results) { console.log(results['one'].toFixed(1)) });
+async.series(taskDict, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
+async.parallel(taskDict, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
+async.parallelLimit(taskDict, 3, function(err, results) {
+    let one = results['one'];
+    console.log(one && one.toFixed(1))
+});
 

async/test/index.ts

@@ -350,9 +350,9 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = async.queue<number, number, Error>(function (level: number, callback: (error : Error, newLevel: number) => void) {
+var aq = async.queue<number, number, Error>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
     console.log('hello ' + level);
-    callback(null, level+1);
+    callback(undefined, level+1);
 });
 
 aq.push(1, function (err : Error, newLevel : number) {
@@ -807,9 +807,9 @@ async.some<number, Error>({
 
 // timeout
 
-function myFunction1(foo : any, callback: (err : Error, result : any) => void ) : void {
+function myFunction1(foo : any, callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 1 ${foo}`);
-	return callback(null, foo);
+	return callback(undefined, foo);
 }
 var wrapped1 = async.timeout(myFunction1, 1000);
 wrapped1({ bar: 'bar' }, function(err : Error, data : any) {
@@ -817,9 +817,9 @@ wrapped1({ bar: 'bar' }, function(err : Error, data : any) {
 });
 
 
-function myFunction2(callback: (err : Error, result : any) => void ) : void {
+function myFunction2(callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 2`);
-	return callback(null, { bar: 'bar' });
+	return callback(undefined, { bar: 'bar' });
 }
 
 var wrapped2 = async.timeout(myFunction2, 1000);
@@ -827,9 +827,9 @@ wrapped2( function(err : Error, data : any) {
     console.log(`async.timeout 2 end ${data}`);
 });
 
-function myFunction3(callback: (err : Error, result : any) => void ) : void {
+function myFunction3(callback: (err?: Error, result?: any) => void ) : void {
 	console.log(`async.timeout 3`);
-	return callback(null, { bar: 'bar' });
+	return callback(undefined, { bar: 'bar' });
 }
 
 var wrapped3 = async.timeout(myFunction3, 1000, { bar: 'bar' });

async/tsconfig.json

@@ -6,7 +6,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "baseUrl": "../",
         "typeRoots": [
             "../"
@@ -20,4 +20,4 @@
         "test/index.ts",
         "test/explicit.ts"
     ]
-}
+}

atom/atom-tests.ts

@@ -1,5 +1,4 @@
 /// <reference types="node" />
-/// <reference types="pathwatcher" />
 
 import path = require("path");
 import _atom = require("atom");

atom/index.d.ts

@@ -3,7 +3,6 @@
 // Definitions by: vvakame <https://github.com/vvakame/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="q" />
 /// <reference types="jquery" />
 /// <reference types="space-pen" />
 /// <reference types="emissary" />
@@ -1519,6 +1518,7 @@ declare var atom:AtomCore.IAtom;
 
 declare module "atom" {
 	import spacePen = require("space-pen");
+	import Q = require("q");
 
 	var $:typeof spacePen.$;
 	var $$:typeof spacePen.$$;

atom/tsconfig.json

@@ -12,6 +12,9 @@
         "typeRoots": [
             "../"
         ],
+        "paths": {
+            "q": [ "q/v0" ]
+        },
         "types": [],
         "noEmit": true,
         "forceConsistentCasingInFileNames": true

aurelia-knockout/aurelia-knockout-tests.ts

@@ -0,0 +1,11 @@
+
+export class ViewModel {
+
+    constructor(private knockoutBindable: KnockoutBindable) {
+    }
+
+    activate(settings: any): void {
+        this.knockoutBindable.applyBindableValues(settings, this);
+        this.knockoutBindable.applyBindableValues(settings, this, true);
+    }
+}

aurelia-knockout/index.d.ts

@@ -0,0 +1,19 @@
+// Type definitions for aurelia-knockout 2.0
+// Project: https://github.com/code-chris/aurelia-knockout
+// Definitions by: Christian Kotzbauer <https://github.com/code-chris>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare interface KnockoutBindable {
+
+    /**
+     * Applys all values from a data object (usually the activation data) to the corresponding instance fields
+     * in the current view model if they are marked as @bindable. By default all matching values from the data object
+     * are applied. To only apply observable values set the last parameter to `true`. Subscriptions are created
+     * for all Knockout observables in the data object to update the view-model values respectively.
+     *
+     * @param data - the data object
+     * @param target - the target view model
+     * @param applyOnlyObservables - `true` if only observable values should be applied, false by default.
+     */
+  applyBindableValues(data: any, target: any, applyOnlyObservables?: boolean): void;
+}

aurelia-knockout/tsconfig.json

@@ -18,6 +18,6 @@
     },
     "files": [
         "index.d.ts",
-        "localforage-tests.ts"
+        "aurelia-knockout-tests.ts"
     ]
-}
+}

auth0/auth0-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="auth0" />
-
 import * as auth0 from 'auth0';
 
 const management = new auth0.ManagementClient({

autobahn/autobahn-tests.ts

@@ -34,7 +34,7 @@ function test_client() {
         session.publish('com.myapp.hello', ['Hello, world!']);
 
         // 3) register a procedure for remoting
-        session.register('com.myapp.add2', myInstance.add2);
+        session.register('com.myapp.add2', myInstance.add2, { invoke: 'roundrobin' });
 
         // 4) call a remote procedure
         session.call<number>('com.myapp.add2', [2, 3]).then(

autobahn/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for AutobahnJS v0.9.6
+// Type definitions for AutobahnJS v0.9.7
 // Project: http://autobahn.ws/js/
 // Definitions by: Elad Zelingher <https://github.com/darkl/>, Andy Hawkins <https://github.com/a904guy/,http://a904guy.com/,http://www.bmbsqd.com>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -177,6 +177,7 @@ declare namespace autobahn {
 
     interface IRegisterOptions {
         disclose_caller?: boolean;
+        invoke?: 'single' | 'roundrobin' | 'random' | 'first' | 'last';
     }
 
     export class Connection {

autosize/autosize-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="autosize" />
-
 // from a NodeList
 autosize(document.querySelectorAll('textarea'));
 

awesomplete/awesomplete-tests.ts

@@ -1,3 +1,5 @@
+import * as Awesomplete from 'awesomplete';
+
 var input = document.getElementById("myinput");
 new Awesomplete(input, {list: "#mylist"});
 
@@ -11,45 +13,48 @@ var awesomplete = new Awesomplete(input);
 awesomplete.list = ["Ada", "Java", "JavaScript", "LOLCODE", "Node.js", "Ruby on Rails"];
 
 new Awesomplete(input, {
-	list: [
-		{ label: "Belarus", value: "BY" },
-		{ label: "China", value: "CN" },
-		{ label: "United States", value: "US" }
-	]
+    list: [
+        { label: "Belarus", value: "BY" },
+        { label: "China", value: "CN" },
+        { label: "United States", value: "US" }
+    ]
 });
 
 // Same with arrays:
 new Awesomplete(input, {
-	list: [
-		[ "Belarus", "BY" ],
-		[ "China", "CN" ],
-		[ "United States", "US" ]
-	]
+    list: [
+        [ "Belarus", "BY" ],
+        [ "China", "CN" ],
+        [ "United States", "US" ]
+    ]
 });
 
 new Awesomplete('input[type="email"]', {
-	list: ["aol.com", "att.net", "comcast.net", "facebook.com", "gmail.com", "gmx.com", "googlemail.com", "google.com", "hotmail.com", "hotmail.co.uk", "mac.com", "me.com", "mail.com", "msn.com", "live.com", "sbcglobal.net", "verizon.net", "yahoo.com", "yahoo.co.uk"],
-	data: function (text: string, input: any) {
-		return input.slice(0, input.indexOf("@")) + "@" + text;
-	},
-	filter: Awesomplete.FILTER_STARTSWITH
+    list: ["aol.com", "att.net", "comcast.net", "facebook.com", "gmail.com",
+           "gmx.com", "googlemail.com", "google.com", "hotmail.com",
+           "hotmail.co.uk", "mac.com", "me.com", "mail.com", "msn.com",
+           "live.com", "sbcglobal.net", "verizon.net", "yahoo.com", "yahoo.co.uk"],
+    data: (text: string, input: string) => {
+        return input.slice(0, input.indexOf("@")) + "@" + text;
+    },
+    filter: Awesomplete.FILTER_STARTSWITH
 });
 
 new Awesomplete('input[data-multiple]', {
-	filter: function(text: string, input: any) {
-		return Awesomplete.FILTER_CONTAINS(text, input.match(/[^,]*$/)[0]);
-	},
+    filter: (text: string, input: any) => {
+        return Awesomplete.FILTER_CONTAINS(text, input.match(/[^,]*$/)[0]);
+    },
 
-	replace: function(text: string) {
-		var before = this.input.value.match(/^.+,\s*|/)[0];
-		this.input.value = before + text + ", ";
-	}
+    replace: (text: string) => {
+        var before = this.input.value.match(/^.+,\s*|/)[0];
+        this.input.value = before + text + ", ";
+    }
 });
 
 var ajax = new XMLHttpRequest();
 ajax.open("GET", "https://restcountries.eu/rest/v1/lang/fr", true);
-ajax.onload = function() {
-	var list = JSON.parse(ajax.responseText).map(function(i: any) { return i.name; });
-	new Awesomplete(document.querySelector("#ajax-example input"),{ list: list });
+ajax.onload = () => {
+    var list = JSON.parse(ajax.responseText).map((i: any) => { return i.name; });
+    new Awesomplete(document.querySelector("#ajax-example input"), { list: list });
 };
-ajax.send();
+ajax.send();

awesomplete/index.d.ts

@@ -1,49 +1,57 @@
-// Type definitions for Awesomplete v1.1.0
+// Type definitions for Awesomplete 1.1
 // Project: https://leaverou.github.io/awesomplete/
-// Definitions by: webbiesdk <https://github.com/webbiesdk/>, Ben Dixon <https://github.com/bmdixon/>
+// Definitions by: webbiesdk <https://github.com/webbiesdk/>, Ben Dixon <https://github.com/bmdixon/>, Trevor Bekolay <https://github.com/tbekolay/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare class Awesomplete {
-	constructor(input: Element | HTMLElement | string, o?: AwesompleteOptions);
-	static all: Array<any>;
-	static $$: (expr: string | NodeSelector, con?: any) => NodeList;
-	static ITEM: (text: string, input: string) => HTMLElement;
-	static $: {
-		(expr: string|Element, con?: NodeSelector): string | Element;
-		regExpEscape: (s: { replace: (arg0: RegExp, arg1: string) => void }) => any;
-		create: (tag: string, o: any) => HTMLElement;
-		fire: (target: EventTarget, type: string, properties: any) => any;
-		siblingIndex: (el: Element) => number;
-	};
-	static FILTER_STARTSWITH: (text: string, input: string) => boolean;
-	static FILTER_CONTAINS: (text: string, input: string) => boolean;
-	static SORT_BYLENGTH: (a: number | any[], b: number | any[]) => number;
-	static REPLACE: (text: any) => void;
-	next: () => void;
-	container: HTMLElement;
-	select: (selected?: HTMLElement, originalTarget?: HTMLElement) => void;
-	previous: () => void;
-	index: number;
-	opened: number;
-	list: string | string[] | Element | { label: string, value: any }[] | [string, string][];
-	input: HTMLElement | string;
-	goto: (i: number) => void;
-	ul: HTMLElement;
-	close: () => void;
-	evaluate: () => void;
-	selected: boolean;
-	open: () => void;
-	status: HTMLElement;
+    constructor(input: Element | HTMLElement | string, o?: Awesomplete.Options);
+    static all: any[];
+    static $$: (expr: string | NodeSelector, con?: any) => NodeList;
+    static ITEM: (text: string, input: string) => HTMLElement;
+    static $: {
+        (expr: string|Element, con?: NodeSelector): string | Element;
+        regExpEscape: (s: { replace: (arg0: RegExp, arg1: string) => void }) => any;
+        create: (tag: string, o: any) => HTMLElement;
+        fire: (target: EventTarget, type: string, properties: any) => any;
+        siblingIndex: (el: Element) => number;
+    };
+    static FILTER_STARTSWITH: (text: string, input: string) => boolean;
+    static FILTER_CONTAINS: (text: string, input: string) => boolean;
+    static SORT_BYLENGTH: (left: number | any[], right: number | any[]) => number;
+    static REPLACE: (text: string) => void;
+    static DATA: (item: Awesomplete.Suggestion) => Awesomplete.Suggestion;
+    next: () => void;
+    container: HTMLElement;
+    select: (selected?: HTMLElement, originalTarget?: HTMLElement) => void;
+    previous: () => void;
+    index: number;
+    opened: number;
+    list: string | Element | Awesomplete.Suggestion[];
+    input: HTMLElement | string;
+    goto: (i: number) => void;
+    ul: HTMLElement;
+    close: () => void;
+    evaluate: () => void;
+    selected: boolean;
+    open: () => void;
+    status: HTMLElement;
 }
 
-interface AwesompleteOptions {
-	list?: string | string[] | Element | { label: string, value: any }[] | [string, string][];
-	minChars?: Number;
-	maxItems?: Number;
-	autoFirst?: boolean;
-    data?: Function;
-	filter?: Function;
-	sort?: Function;
-	item?: Function;
-	replace?: Function;
+declare namespace Awesomplete {
+    type Suggestion = string | {label: string | any, value: string | any} | [string, string];
+
+    interface Options {
+        list?: string | string[] | Element | { label: string, value: any }[] | [string, string][];
+        minChars?: number;
+        maxItems?: number;
+        autoFirst?: boolean;
+        data?: (item: Suggestion, input: string) => string;
+        filter?: (text: string, input: string) => boolean;
+        sort?: (left: number | any[], right: number | any[]) => number;
+        item?: (text: string, input: string) => HTMLElement;
+        replace?: (text: string) => void;
+    }
 }
+
+export = Awesomplete;
+export as namespace Awesomplete;

aws-lambda/aws-lambda-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="aws-lambda" />
-
 var str: string = "any string";
 var date: Date = new Date();
 var anyObj: any = { abc: 123 };
@@ -13,6 +11,12 @@ var clientContextClient: AWSLambda.ClientContextClient;
 var context: AWSLambda.Context;
 var identity: AWSLambda.CognitoIdentity;
 var proxyResult: AWSLambda.ProxyResult;
+var snsEvt: AWSLambda.SNSEvent;
+var snsEvtRecs: Array<AWSLambda.SNSEventRecord>;
+var snsEvtRec: AWSLambda.SNSEventRecord;
+var snsMsg: AWSLambda.SNSMessage;
+var snsMsgAttr: AWSLambda.SNSMessageAttribute;
+var snsMsgAttrs: AWSLambda.SNSMessageAttributes;
 
 /* API Gateway Event */
 str = apiGwEvt.body;
@@ -44,9 +48,36 @@ str = apiGwEvt.requestContext.resourceId;
 str = apiGwEvt.requestContext.resourcePath;
 str = apiGwEvt.resource;
 
+/* SNS Event */
+snsEvtRecs = snsEvt.Records;
+
+str = snsEvtRec.EventSource;
+str = snsEvtRec.EventSubscriptionArn;
+str = snsEvtRec.EventVersion;
+snsMsg = snsEvtRec.Sns;
+
+str = snsMsg.SignatureVersion;
+str = snsMsg.Timestamp;
+str = snsMsg.Signature;
+str = snsMsg.SigningCertUrl;
+str = snsMsg.MessageId;
+str = snsMsg.Message;
+snsMsgAttrs = snsMsg.MessageAttributes;
+str = snsMsg.Type;
+str = snsMsg.UnsubscribeUrl;
+str = snsMsg.TopicArn;
+str = snsMsg.Subject;
+
+snsMsgAttrs["example"] = snsMsgAttr;
+
+str = snsMsgAttr.Type;
+str = snsMsgAttr.Value;
+
 /* Lambda Proxy Result */
 num = proxyResult.statusCode;
-str = proxyResult.headers["example"];
+proxyResult.headers["example"] = str;
+proxyResult.headers["example"] = b;
+proxyResult.headers["example"] = num;
 str = proxyResult.body
 
 /* Context */

aws-lambda/index.d.ts

@@ -39,6 +39,41 @@ interface APIGatewayEvent {
     resource: string;
 }
 
+// SNS "event"
+interface SNSMessageAttribute {
+    Type: string;
+    Value: string;
+}
+
+interface SNSMessageAttributes {
+    [name: string]: SNSMessageAttribute;
+}
+
+interface SNSMessage {
+    SignatureVersion: string;
+    Timestamp: string;
+    Signature: string;
+    SigningCertUrl: string;
+    MessageId: string;
+    Message: string;
+    MessageAttributes: SNSMessageAttributes;
+    Type: string;
+    UnsubscribeUrl: string;
+    TopicArn: string;
+    Subject: string;
+}
+
+interface SNSEventRecord {
+    EventVersion: string;
+    EventSubscriptionArn: string;
+    EventSource: string;
+    Sns: SNSMessage;
+}
+
+interface SNSEvent {
+    Records: Array<SNSEventRecord>;
+}
+
 // Context
 // http://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-context.html
 interface Context {
@@ -97,7 +132,7 @@ interface ClientContextEnv {
 interface ProxyResult {
     statusCode: number;
     headers?: {
-      [header: string]: string;
+        [header: string]: boolean | number | string;
     },
     body: string;
 }
@@ -110,8 +145,8 @@ interface ProxyResult {
  * @param context – runtime information of the Lambda function that is executing.
  * @param callback – optional callback to return information to the caller, otherwise return value is null.
  */
-export type Handler = (event: any, context: Context, callback?: Callback)  => void;
-export type ProxyHandler = (event: APIGatewayEvent, context: Context, callback?: ProxyCallback)  => void;
+export type Handler = (event: any, context: Context, callback?: Callback) => void;
+export type ProxyHandler = (event: APIGatewayEvent, context: Context, callback?: ProxyCallback) => void;
 
 /**
  * Optional callback parameter.

aws-serverless-express/aws-serverless-express-tests.ts

@@ -1,9 +1,10 @@
-/// <reference types="express"/>
-
 import * as awsServerlessExpress from 'aws-serverless-express';
 import * as express from 'express';
+import { eventContext } from 'aws-serverless-express/middleware';
 
 const app = express();
+app.use(eventContext());
+
 const server = awsServerlessExpress.createServer(app, () => {});
 
 const mockEvent = {

aws-serverless-express/index.d.ts

@@ -1,6 +1,6 @@
-// Type definitions for aws-serverless-express
+// Type definitions for aws-serverless-express 2.1
 // Project: https://github.com/awslabs/aws-serverless-express
-// Definitions by: Ben Speakman <https://github.com/threesquared>
+// Definitions by: Ben Speakman <https://github.com/threesquared>, Josh Caffey <https://github.com/jcaffey>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="node"/>
@@ -16,4 +16,4 @@ export function proxy(
     server: http.Server,
     event: any,
     context: lambda.Context
-): void;
+): void;

aws-serverless-express/middleware.d.ts

@@ -0,0 +1,8 @@
+import { RequestHandler } from 'express';
+
+export interface Options {
+    reqPropKey?: string;
+    deleteHeaders?: boolean;
+}
+
+export function eventContext(options?: Options): RequestHandler;

aws-serverless-express/tsconfig.json

@@ -17,6 +17,7 @@
     },
     "files": [
         "index.d.ts",
+        "middleware.d.ts",
         "aws-serverless-express-tests.ts"
     ]
-}
+}

axel/axel-tests.ts

@@ -0,0 +1,7 @@
+
+import * as axel from 'axel';
+
+axel.clear();
+axel.bg(0,255,0);
+axel.line(1,1,10,10);
+axel.cursor.restore();

axel/index.d.ts

@@ -0,0 +1,37 @@
+// Type definitions for Axel module
+// Project: https://github.com/F1LT3R/axel
+// Definitions by: Ruslan Molodyko <https://github.com/ruslan-molodyko>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare class Axel {
+    brush: string;
+    rows: number;
+    cols: number;
+    cursor: cursorInterface;
+
+    lerp(p1: number, p2: number, m: number): number;
+    circ(x: number, y: number, m: number): number;
+    goto(x: number, y: number): void;
+    scrub(x1: number, y1: number, w: number, h: number): void;
+    box(x1: number, y1: number, w: number, h: number): void;
+    point(x: number, y: number, char: string): void;
+    dist(x1: number, y1: number, x2: number, y2: number): number;
+    line(x1: number, y1: number, x2: number, y2: number): void;
+    text(x: number, y: number, text: string): void;
+    fg(r: number, g: number, b: number): void;
+    bg(r: number, g: number, b: number): void;
+    draw(cb: Function): void;
+    clear(): void;
+}
+
+declare interface cursorInterface {
+    on(): void;
+    off(): void;
+    reset(): void;
+    restore(): void;
+}
+
+declare module 'axel' {
+    const instance: Axel;
+    export = instance;
+}

axel/tsconfig.json

@@ -0,0 +1,22 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "lib": [
+      "es6"
+    ],
+    "noImplicitAny": true,
+    "noImplicitThis": true,
+    "strictNullChecks": false,
+    "baseUrl": "../",
+    "typeRoots": [
+      "../"
+    ],
+    "types": [],
+    "noEmit": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+    "axel-tests.ts",
+    "index.d.ts"
+  ]
+}

babel-template/babel-template-tests.ts

@@ -1,7 +1,4 @@
-
 /// <reference types="babel-generator" />
-/// <reference types="babel-types" />
-
 
 // Example from https://github.com/babel/babel/tree/master/packages/babel-template
 import template = require('babel-template');

babel-traverse/babel-traverse-tests.ts

@@ -1,5 +1,3 @@
-
-/// <reference types="babel-types" />
 /// <reference types="babylon" />
 
 

babylon/babylon-tests.ts

@@ -1,8 +1,3 @@
-
-/// <reference types="babel-types" />
-/// <reference types="babel-types" />
-
-
 // Example from https://github.com/thejameskyle/babel-handbook/blob/master/translations/en/plugin-handbook.md#babylon
 import * as babylon from "babylon";
 declare function assert(expr: boolean): void;

backbone.layoutmanager/backbone.layoutmanager-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery"/>
-
 import * as Backbone from 'backbone';
 
 // Example code.
@@ -26,7 +24,7 @@ class View extends Backbone.Layout<Backbone.Model> {
             "mouseleave": "removeElement"
         }
     }
-    
+
     wrapElement(): void {
         this.$el.wrap("<b>");
     }

backbone/backbone-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery" />
-
 function test_events() {
 
     var object = new Backbone.Events();

bardjs/bardjs-tests.ts

@@ -1,6 +1,3 @@
-/// <reference types="mocha" />
-/// <reference types="chai" />
-
 import * as angular from 'angular';
 import 'angular-mocks';
 

batch-stream/batch-stream-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-
 import fs = require('fs');
 import BatchStream = require('batch-stream');
 

bazinga-translator/bazinga-translator-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="bazinga-translator" />
-
 Translator.fallback = 'en';
 Translator.defaultDomain = 'messages';
 

bezier-js/bezier-js-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="bezier-js" />
-
 function test() {
 
     var bezierjs: typeof BezierJs;

big-integer/big-integer-tests.ts

@@ -113,5 +113,6 @@ isBigInteger = x.times( "100" );
 isNumber = x.toJSNumber();
 
 isString = x.toString();
+isString = x.toString(36);
 
 isNumber = x.valueOf();

big-integer/index.d.ts

@@ -195,7 +195,7 @@ interface BigInteger {
     toJSNumber(): number;
 
     /** Converts a bigInt to a string. */
-    toString(): string;
+    toString( radix?: number ): string;
 
     /** Converts a bigInt to a native Javascript number. This override allows you to use native arithmetic operators without explicit conversion. */
     valueOf(): number;

bingmaps/bingmaps-tests.ts

@@ -1,10 +1,3 @@
-/// <reference path="Microsoft.Maps.AdvancedShapes.d.ts"/>
-/// <reference path="Microsoft.Maps.Directions.d.ts"/>
-/// <reference path="Microsoft.Maps.Search.d.ts"/>
-/// <reference path="Microsoft.Maps.Themes.BingTheme.d.ts"/>
-/// <reference path="Microsoft.Maps.Traffic.d.ts"/>
-/// <reference path="Microsoft.Maps.VenueMaps.d.ts"/>
-
 namespace BingMapsTests {
 
     // An interactive set of Bing Maps AJAX control usages can be found at http://www.bingmapsportal.com/isdk/ajaxv7

bit-array/bit-array-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="bit-array" />
-
 import BitArray = require("bit-array");
 
 const a = new BitArray(32);

blob-stream/blob-stream-tests.ts

@@ -1,6 +1,3 @@
-
-/// <reference types="node" />
-
 var bl = require('blob-stream');
 
 var blob = bl.toBlob();

blue-tape/blue-tape-tests.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 /// <reference types="bluebird" />
 
 import tape = require('blue-tape');

bluebird-global/index.d.ts

@@ -80,6 +80,8 @@ declare global {
         // then: typeof Bluebird.prototype.then;
         thenReturn: typeof Bluebird.prototype.thenReturn;
         thenThrow: typeof Bluebird.prototype.thenThrow;
+        catchReturn: typeof Bluebird.prototype.catchReturn;
+        catchThrow: typeof Bluebird.prototype.catchThrow;
         throw: typeof Bluebird.prototype.throw;
         timeout: typeof Bluebird.prototype.timeout;
         toJSON: typeof Bluebird.prototype.toJSON;

bluebird-retry/bluebird-retry-tests.ts

@@ -1,5 +1,3 @@
-
-/// <reference types="bluebird" />
 import Promise = require('bluebird');
 import retry = require('bluebird-retry');
 

bluebird-retry/index.d.ts

@@ -17,6 +17,9 @@ declare namespace retry {
         timeout?: number;
         max_tries?: number;
         predicate?: any;
+        throw_original?: boolean;
+        context?: any;
+        args?: any;
     }
 
 }

bluebird/bluebird-tests.ts

@@ -506,6 +506,15 @@ fooProm = fooProm.thenThrow(err);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+barProm = fooProm.catchReturn(bar);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+// fooProm
+fooProm = fooProm.catchThrow(err);
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 str = fooProm.toString();
 
 obj = fooProm.toJSON();

bluebird/index.d.ts

@@ -248,6 +248,37 @@ declare class Bluebird<R> implements Bluebird.Thenable<R>, Bluebird.Inspection<R
   throw(reason: Error): Bluebird<R>;
   thenThrow(reason: Error): Bluebird<R>;
 
+  /**
+   * Convenience method for:
+   *
+   * <code>
+   * .catch(function() {
+   *    return value;
+   * });
+   * </code>
+   *
+   * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.catchReturn()`
+   */
+  catchReturn<U>(value: U): Bluebird<U>;
+  catchReturn<U>(predicate: (error: any) => boolean, value: U): Bluebird<U | R>;
+  catchReturn<E extends Error, U>(ErrorClass: new (...args: any[]) => E, value: U): Bluebird<U | R>;
+  catchReturn<U>(predicate: Object, value: U): Bluebird<U | R>;
+
+  /**
+   * Convenience method for:
+   *
+   * <code>
+   * .catch(function() {
+   *    throw reason;
+   * });
+   * </code>
+   * Same limitations apply as with `.catchReturn()`.
+   */
+  catchThrow(reason: Error): Bluebird<R>;
+  catchThrow(predicate: (error: any) => boolean, reason: Error): Bluebird<R>;
+  catchThrow<E extends Error, U>(ErrorClass: new (...args: any[]) => E, reason: Error): Bluebird<R>;
+  catchThrow(predicate: Object, reason: Error): Bluebird<R>;
+
   /**
    * Convert to String.
    */

bookshelf/index.d.ts

@@ -17,7 +17,7 @@ interface Bookshelf extends Bookshelf.Events<any> {
 	Collection: typeof Bookshelf.Collection;
 
 	plugin(name: string | string[] | Function, options?: any): Bookshelf;
-	transaction<T>(callback: (transaction: knex.Transaction) => T): BlueBird<T>;
+	transaction<T>(callback: (transaction: knex.Transaction) => BlueBird<T>): BlueBird<T>;
 }
 
 declare function Bookshelf(knex: knex): Bookshelf;

bootbox/bootbox-tests.ts

@@ -6,7 +6,7 @@ bootbox.alert("Are we ok with callback?", function () {
 	console.log("Callback called!");
 });
 bootbox.alert({
-	size: "medium",
+	size: "small",
 	message: "Are we ok with callback and custom button?",
 	callback: function () {
 		console.log("Callback called!");
@@ -38,7 +38,29 @@ bootbox.prompt({
 		console.log(result);
 	}
 });
-
+bootbox.prompt({
+    title: "This is a prompt with a set of checkbox inputs!",
+    inputType: 'checkbox',
+    inputOptions: [
+        {
+            text: 'Choice One',
+            value: '1',
+            group: 'Group 1'
+        },
+        {
+            text: 'Choice Two',
+            value: '2',
+            group: 'Group 1'
+        },
+        {
+            text: 'Choice Three',
+            value: '3'
+        }
+    ],
+    callback: function (result) {
+        console.log(result);
+    }
+});
 
 bootbox.dialog({
 	title: "Wassup?",

bootbox/index.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for Bootbox 4.4.0
 // Project: https://github.com/makeusabrew/bootbox
-// Definitions by: Vincent Bortone <https://github.com/vbortone/>, Kon Pik <https://github.com/konpikwastaken/>, Anup Kattel <https://github.com/kanup/>, Dominik Schroeter <https://github.com/icereed/>, Troy McKinnon <https://github.com/trodi/>
+// Definitions by: Vincent Bortone <https://github.com/vbortone/>, Kon Pik <https://github.com/konpikwastaken/>, Anup Kattel <https://github.com/kanup/>, Dominik Schroeter <https://github.com/icereed/>, Troy McKinnon <https://github.com/trodi/>, Stanny Nuytkens <https://github.com/stannynuytkens>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="jquery" />
@@ -15,7 +15,8 @@ interface BootboxBaseOptions {
 	closeButton?: boolean;
 	animate?: boolean;
 	className?: string;
-	size?: string;
+	/** All other values result in medium */
+	size?: "small" | "large";
 	buttons?: BootboxButtonMap; // complex object where each key is of type BootboxButton
 }
 
@@ -40,9 +41,10 @@ interface BootboxConfirmOptions extends BootboxDialogOptions {
 interface BootboxPromptOptions extends BootboxBaseOptions {
 	title: string;
 	value?: string;
-	inputType?: string;
+	inputType?: "text" | "textarea" | "email" | "select" | "checkbox" | "date" | "time" | "number" | "password";
 	callback: (result: string) => any;
 	buttons?: BootboxConfirmPromptButtonMap;
+	inputOptions?: { text: string, value: string, group?: string }[];
 }
 
 /** Bootbox options available when setting defaults for modals */

bootpag/bootpag-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery"/>
-
 var pagerSelector = ".bootpager";
 var $pager = $(pagerSelector);
 

bootstrap-datepicker/bootstrap-datepicker-tests.ts

@@ -1,4 +1,3 @@
-/// <reference path="index.d.ts"/>
 function tests_simple() {
     $('#datepicker').datepicker();
     $('#datepicker').datepicker({

bootstrap-maxlength/bootstrap-maxlength-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery"/>
-
 // Examples from the projects github page
 $('input[maxlength]').maxlength();
 

bootstrap-notify/bootstrap-notify-tests.ts

@@ -1,6 +1,3 @@
-
-/// <reference types="jquery" />
-
 //Test for bootstrap-notify v3.1.3
 //Copied example directly from Bootstrap-notify site
 

bootstrap-select/bootstrap-select-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery"/>
-
 $(".selectpicker").selectpicker({
     actionsBox: true,
     container: "body",

bootstrap-slider/bootstrap-slider-tests.ts

@@ -1,6 +1,3 @@
-/// <reference types="jquery" />
-
-
 $(function() {
     // examples from http://seiyria.github.io/bootstrap-slider/
 

bootstrap-switch/bootstrap-switch-tests.ts

@@ -1,9 +1,6 @@
-/// <reference types="jquery"/>
-
-
 function test_cases() {
 	$('#switch').bootstrapSwitch();
-	
+
 	$('#switch').bootstrapSwitch({
 		state: false
 	});
@@ -15,7 +12,7 @@ function test_cases() {
 
 	//var mySwitch = $('#switch').get(0);
 	//mySwitch.toggleAnimate();
-	
+
 	$('#switch').bootstrapSwitch('state', true, true);
 
 	$('#switch').bootstrapSwitch('state') === true;

bootstrap-touchspin/bootstrap-touchspin-tests.ts

@@ -1,6 +1,3 @@
-/// <reference types="jquery" />
-
-
 $(function () {
     // Example 1 from http://www.virtuosoft.eu/code/bootstrap-touchspin/
     $("input[name='demo1']").TouchSpin({
@@ -26,7 +23,7 @@ $(function () {
     $("input[name='demo_vertical']").TouchSpin({
         verticalbuttons: true
     });
-    
+
     // Example 4 from http://www.virtuosoft.eu/code/bootstrap-touchspin/
     $("input[name='demo_vertical2']").TouchSpin({
         verticalbuttons: true,

bootstrap-validator/bootstrap-validator-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery" />
-
 $('#myForm').validator();
 $('#myForm').validator('update');
 $('#myForm').validator('validate');

bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="jquery"/>
-
 import * as moment from "moment";
 
 const dp = $("#picker").datetimepicker().data("DateTimePicker");

bootstrap/bootstrap-tests.ts

@@ -1,6 +1,3 @@
-/// <reference types="jquery" />
-
-
 $('body').off('.data-api');
 $('body').off('.alert.data-api');
 

browser-resolve/browser-resolve-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="browser-resolve" />
-
 import * as browserResolve from 'browser-resolve';
 
 function basic_test_async(callback: (err?: Error, resolved?: string) => void) {

bunyan-blackhole/bunyan-blackhole-tests.ts

@@ -0,0 +1,26 @@
+import blackhole = require("bunyan-blackhole");
+
+
+
+var logsLaboursLost = blackhole("lost");
+
+const rotten = new Error("Something is rotten in the state of Denmark");
+
+logsLaboursLost.info(rotten, "Play %s", "Hamlet");
+logsLaboursLost.debug(rotten, "Play %s", "King Lear");
+logsLaboursLost.trace(rotten, "Play %s", "Much Ado About Nothing");
+logsLaboursLost.warn(rotten, "Play %s", "All's Well That Ends Well");
+logsLaboursLost.error(rotten, "Play %s", "Romeo and Juliet");
+
+logsLaboursLost.error("Something is rotten in the state of Denmark");
+
+logsLaboursLost.debug({character: "Marcellus", play: "King Lear"}, "Friends of my soul, you twain");
+logsLaboursLost.trace({play: "All's Well That Ends Well"}, "Love all, trust a few, do wrong to none");
+logsLaboursLost.info({play: "Much Ado About Nothing"}, "Let me be that I am and seek not to alter me.");
+logsLaboursLost.warn({play: "All's Well That Ends Well"}, "Love all, trust a few, do wrong to none");
+logsLaboursLost.error({play: "All's Well That Ends Well"}, "Love all, trust a few, do wrong to none");
+
+var hamlet = logsLaboursLost.child({play: "Hamlet"});
+hamlet.info({character: "Polonius"}, "Though this be madness, yet there is method in't");
+
+

bunyan-blackhole/index.d.ts

@@ -0,0 +1,14 @@
+// Type definitions for bunyan-blackhole 0.2
+// Project: https://github.com/Floby/node-bunyan-blackhole
+// Definitions by: Olivier Chevet <https://github.com/olivr70>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import * as Logger from "bunyan";
+
+/**
+ * Constructor.
+ * @param {string} [name] name of the blackhole Logger
+ * @return {Logger} A bunyan logger .
+ */
+declare function bunyanBlackHole(name: string): Logger;
+export = bunyanBlackHole;

bunyan-blackhole/tsconfig.json

@@ -17,6 +17,6 @@
     },
     "files": [
         "index.d.ts",
-        "node-form-tests.ts"
+        "bunyan-blackhole-tests.ts"
     ]
 }

bunyan-blackhole/tslint.json

@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }

bunyan/bunyan-tests.ts

@@ -86,26 +86,32 @@ var object = {
     test: 123
 };
 
+log.trace();
 log.trace(buffer);
 log.trace(error);
 log.trace(object);
 log.trace('Hello, %s', 'world!');
+log.debug();
 log.debug(buffer);
 log.debug(error);
 log.debug(object);
 log.debug('Hello, %s', 'world!');
+log.info();
 log.info(buffer);
 log.info(error);
 log.info(object);
 log.info('Hello, %s', 'world!');
+log.warn();
 log.warn(buffer);
 log.warn(error);
 log.warn(object);
 log.warn('Hello, %s', 'world!');
+log.error();
 log.error(buffer);
 log.error(error);
 log.error(object);
 log.error('Hello, %s', 'world!');
+log.fatal();
 log.fatal(buffer);
 log.fatal(error);
 log.fatal(object);

bunyan/index.d.ts

@@ -22,30 +22,191 @@ declare class Logger extends EventEmitter {
     fields: any;
     src: boolean;
 
+    /**
+     * Returns a boolean: is the `trace` level enabled?
+     * 
+     * This is equivalent to `log.isTraceEnabled()` or `log.isEnabledFor(TRACE)` in log4j.
+     */
+    trace(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     trace(error: Error, format?: any, ...params: any[]): void;
+
     trace(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    trace(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     trace(obj: Object, format?: any, ...params: any[]): void;
-    trace(format: string, ...params: any[]): void;
+
+    /**
+     * Returns a boolean: is the `debug` level enabled?
+     * 
+     * This is equivalent to `log.isDebugEnabled()` or `log.isEnabledFor(DEBUG)` in log4j.
+     */
+    debug(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     debug(error: Error, format?: any, ...params: any[]): void;
+
     debug(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    debug(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     debug(obj: Object, format?: any, ...params: any[]): void;
-    debug(format: string, ...params: any[]): void;
+
+    /**
+     * Returns a boolean: is the `info` level enabled?
+     * 
+     * This is equivalent to `log.isInfoEnabled()` or `log.isEnabledFor(INFO)` in log4j.
+     */
+    info(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     info(error: Error, format?: any, ...params: any[]): void;
+
     info(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    info(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     info(obj: Object, format?: any, ...params: any[]): void;
-    info(format: string, ...params: any[]): void;
+
+    /**
+     * Returns a boolean: is the `warn` level enabled?
+     * 
+     * This is equivalent to `log.isWarnEnabled()` or `log.isEnabledFor(WARN)` in log4j.
+     */
+    warn(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     warn(error: Error, format?: any, ...params: any[]): void;
+
     warn(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    warn(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     warn(obj: Object, format?: any, ...params: any[]): void;
-    warn(format: string, ...params: any[]): void;
+
+    /**
+     * Returns a boolean: is the `error` level enabled?
+     * 
+     * This is equivalent to `log.isErrorEnabled()` or `log.isEnabledFor(ERROR)` in log4j.
+     */
+    error(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     error(error: Error, format?: any, ...params: any[]): void;
+
     error(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    error(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     error(obj: Object, format?: any, ...params: any[]): void;
-    error(format: string, ...params: any[]): void;
+
+    /**
+     * Returns a boolean: is the `fatal` level enabled?
+     * 
+     * This is equivalent to `log.isFatalEnabled()` or `log.isEnabledFor(FATAL)` in log4j.
+     */
+    fatal(): boolean;
+
+    /**
+     * Special case to log an `Error` instance to the record.
+     * This adds an `err` field with exception details
+     * (including the stack) and sets `msg` to the exception
+     * message or you can specify the `msg`.
+     */
     fatal(error: Error, format?: any, ...params: any[]): void;
+
     fatal(buffer: Buffer, format?: any, ...params: any[]): void;
+
+    /**
+     * Uses `util.format` for msg formatting.
+     */
+    fatal(format: string | number, ...params: any[]): void;
+
+    /**
+     * The first field can optionally be a "fields" object, which
+     * is merged into the log record.
+     * 
+     * To pass in an Error *and* other fields, use the `err`
+     * field name for the Error instance.
+     */
     fatal(obj: Object, format?: any, ...params: any[]): void;
-    fatal(format: string, ...params: any[]): void;
 }
 
 declare namespace Logger {

business-rules-engine/Validation.d.ts

@@ -3,8 +3,6 @@
 // Definitions by: Roman Samec <https://github.com/rsamec>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="q" />
-
 declare namespace Validation {
     interface IErrorCustomMessage {
         (config: any, args: any): string;

business-rules-engine/business-rules-engine-tests.ts

@@ -1,4 +1,3 @@
-/// <reference types="q" />
 import * as Validators from 'business-rules-engine/node-validators';
 import Validation = require("business-rules-engine");
 

business-rules-engine/index.d.ts

@@ -4,7 +4,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 // Source: typings/business-rules-engine/Validation.d.ts
-/// <reference types="q" />
 
 import * as Q from "q";
 

business-rules-engine/node-validators.d.ts

@@ -3,7 +3,6 @@
 // Definitions by: Roman Samec <https://github.com/rsamec>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference types="q" />
 /// <reference types="node" />
 
 import Validation = require("business-rules-engine");

business-rules-engine/tsconfig.json

@@ -11,6 +11,9 @@
         "typeRoots": [
             "../"
         ],
+        "paths": {
+            "q": [ "q/v0" ]
+        },
         "types": [],
         "noEmit": true,
         "forceConsistentCasingInFileNames": true

c3/c3-tests.ts

@@ -368,7 +368,9 @@ function line_examples() {
         data: {},
         line: {
             connectNull: true,
-            step_type: "step-after"
+            step: {
+                type: "step-after"
+            }
         }
     });
 }

c3/index.d.ts

@@ -145,7 +145,9 @@ declare namespace c3 {
             /**
              * Change step type for step chart. 'step', 'step-before' and 'step-after' can be used.
              */
-            step_type?: string;
+            step?: {
+                 type: string;
+             };
         };
 
         area?: {

cachefactory/cachefactory-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="cachefactory" />
-
 CacheFactory.get('test');
 
 CacheFactory.createCache('test', {

cal-heatmap/cal-heatmap-tests.ts

@@ -1,6 +1,4 @@
-
 /// <reference types="jquery" />
-/// <reference types="d3" />
 
 var cal = new CalHeatMap();
 cal.init();

cassandra-driver/cassandra-driver-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="cassandra-driver" />
-
 import * as cassandra from 'cassandra-driver';
 import * as util from 'util';
 

cbor/cbor-tests.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-
 import cbor = require('cbor');
 import assert = require('assert');
 import fs = require('fs');

chai-as-promised/chai-as-promised-tests.ts

@@ -1,7 +1,3 @@
-
-/// <reference types="promises-a-plus" />
-/// <reference types="q" />
-
 import chai = require('chai');
 import chaiAsPromised = require('chai-as-promised');
 import Q = require('q');
@@ -12,7 +8,7 @@ class TestClass {}
 
 // ReSharper disable WrongExpressionStatement
 // BDD API (expect)
-var thenableNum: PromisesAPlus.Thenable<number>;
+var thenableNum: PromiseLike<number>;
 thenableNum = chai.expect(thenableNum).to.eventually.equal(3);
 thenableNum = chai.expect(thenableNum).to.eventually.have.property('foo');
 thenableNum = chai.expect(thenableNum).to.become(3);
@@ -56,7 +52,7 @@ Q.all([
 ]).should.notify(() => console.log('done'));
 
 // Assert API
-var thenableVoid: PromisesAPlus.Thenable<void>;
+var thenableVoid: PromiseLike<void>;
 thenableVoid = chai.assert.eventually.equal(thenableNum, 4, 'Message');
 thenableVoid = chai.assert.isFulfilled(thenableNum, "optional message");
 thenableVoid = chai.assert.becomes(thenableNum, "foo", "optional message");

chai-as-promised/index.d.ts

@@ -4,7 +4,6 @@
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference types="chai" />
-/// <reference types="promises-a-plus" />
 
 declare module 'chai-as-promised' {
     function chaiAsPromised(chai: any, utils: any): void;
@@ -27,7 +26,7 @@ declare namespace Chai {
     // Eventually does not have .then(), but PromisedAssertion have.
     interface Eventually extends PromisedLanguageChains, PromisedNumericComparison, PromisedTypeComparison {
         // From chai-as-promised
-        become(expected: PromisesAPlus.Thenable<any>): PromisedAssertion;
+        become(expected: PromiseLike<any>): PromisedAssertion;
         fulfilled: PromisedAssertion;
         rejected: PromisedAssertion;
         rejectedWith(expected: any, message?: string | RegExp): PromisedAssertion;
@@ -74,7 +73,7 @@ declare namespace Chai {
         members: PromisedMembers;
     }
 
-    interface PromisedAssertion extends Eventually, PromisesAPlus.Thenable<any> {
+    interface PromisedAssertion extends Eventually, PromiseLike<any> {
     }
 
     interface PromisedLanguageChains {
@@ -181,111 +180,111 @@ declare namespace Chai {
     // For Assert API
     interface Assert {
         eventually: PromisedAssert;
-        isFulfilled(promise: PromisesAPlus.Thenable<any>, message?: string): PromisesAPlus.Thenable<void>;
-        becomes(promise: PromisesAPlus.Thenable<any>, expected: any, message?: string): PromisesAPlus.Thenable<void>;
-        doesNotBecome(promise: PromisesAPlus.Thenable<any>, expected: any, message?: string): PromisesAPlus.Thenable<void>;
-        isRejected(promise: PromisesAPlus.Thenable<any>, message?: string): PromisesAPlus.Thenable<void>;
-        isRejected(promise: PromisesAPlus.Thenable<any>, expected: any, message?: string): PromisesAPlus.Thenable<void>;
-        isRejected(promise: PromisesAPlus.Thenable<any>, match: RegExp, message?: string): PromisesAPlus.Thenable<void>;
-        notify(fn: Function): PromisesAPlus.Thenable<void>;
+        isFulfilled(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        becomes(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        doesNotBecome(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, expected: any, message?: string): PromiseLike<void>;
+        isRejected(promise: PromiseLike<any>, match: RegExp, message?: string): PromiseLike<void>;
+        notify(fn: Function): PromiseLike<void>;
     }
 
     export interface PromisedAssert {
-        fail(actual?: any, expected?: any, msg?: string, operator?: string): PromisesAPlus.Thenable<void>;
+        fail(actual?: any, expected?: any, msg?: string, operator?: string): PromiseLike<void>;
 
-        ok(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        notOk(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        ok(val: any, msg?: string): PromiseLike<void>;
+        notOk(val: any, msg?: string): PromiseLike<void>;
 
-        equal(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
-        notEqual(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
+        equal(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
 
-        strictEqual(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
-        notStrictEqual(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
+        strictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notStrictEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
 
-        deepEqual(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
-        notDeepEqual(act: any, exp: any, msg?: string): PromisesAPlus.Thenable<void>;
+        deepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
+        notDeepEqual(act: any, exp: any, msg?: string): PromiseLike<void>;
 
-        isTrue(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isFalse(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isTrue(val: any, msg?: string): PromiseLike<void>;
+        isFalse(val: any, msg?: string): PromiseLike<void>;
 
-        isNull(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotNull(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isNull(val: any, msg?: string): PromiseLike<void>;
+        isNotNull(val: any, msg?: string): PromiseLike<void>;
 
-        isUndefined(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isDefined(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isUndefined(val: any, msg?: string): PromiseLike<void>;
+        isDefined(val: any, msg?: string): PromiseLike<void>;
 
-        isFunction(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotFunction(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isFunction(val: any, msg?: string): PromiseLike<void>;
+        isNotFunction(val: any, msg?: string): PromiseLike<void>;
 
-        isObject(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotObject(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isObject(val: any, msg?: string): PromiseLike<void>;
+        isNotObject(val: any, msg?: string): PromiseLike<void>;
 
-        isArray(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotArray(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isArray(val: any, msg?: string): PromiseLike<void>;
+        isNotArray(val: any, msg?: string): PromiseLike<void>;
 
-        isString(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotString(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isString(val: any, msg?: string): PromiseLike<void>;
+        isNotString(val: any, msg?: string): PromiseLike<void>;
 
-        isNumber(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotNumber(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isNumber(val: any, msg?: string): PromiseLike<void>;
+        isNotNumber(val: any, msg?: string): PromiseLike<void>;
 
-        isBoolean(val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        isNotBoolean(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        isBoolean(val: any, msg?: string): PromiseLike<void>;
+        isNotBoolean(val: any, msg?: string): PromiseLike<void>;
 
-        typeOf(val: any, type: string, msg?: string): PromisesAPlus.Thenable<void>;
-        notTypeOf(val: any, type: string, msg?: string): PromisesAPlus.Thenable<void>;
+        typeOf(val: any, type: string, msg?: string): PromiseLike<void>;
+        notTypeOf(val: any, type: string, msg?: string): PromiseLike<void>;
 
-        instanceOf(val: any, type: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        notInstanceOf(val: any, type: Function, msg?: string): PromisesAPlus.Thenable<void>;
+        instanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
+        notInstanceOf(val: any, type: Function, msg?: string): PromiseLike<void>;
 
-        include(exp: string, inc: any, msg?: string): PromisesAPlus.Thenable<void>;
-        include(exp: any[], inc: any, msg?: string): PromisesAPlus.Thenable<void>;
+        include(exp: string, inc: any, msg?: string): PromiseLike<void>;
+        include(exp: any[], inc: any, msg?: string): PromiseLike<void>;
 
-        notInclude(exp: string, inc: any, msg?: string): PromisesAPlus.Thenable<void>;
-        notInclude(exp: any[], inc: any, msg?: string): PromisesAPlus.Thenable<void>;
+        notInclude(exp: string, inc: any, msg?: string): PromiseLike<void>;
+        notInclude(exp: any[], inc: any, msg?: string): PromiseLike<void>;
 
-        match(exp: any, re: RegExp, msg?: string): PromisesAPlus.Thenable<void>;
-        notMatch(exp: any, re: RegExp, msg?: string): PromisesAPlus.Thenable<void>;
+        match(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
+        notMatch(exp: any, re: RegExp, msg?: string): PromiseLike<void>;
 
-        property(obj: Object, prop: string, msg?: string): PromisesAPlus.Thenable<void>;
-        notProperty(obj: Object, prop: string, msg?: string): PromisesAPlus.Thenable<void>;
-        deepProperty(obj: Object, prop: string, msg?: string): PromisesAPlus.Thenable<void>;
-        notDeepProperty(obj: Object, prop: string, msg?: string): PromisesAPlus.Thenable<void>;
+        property(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        deepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
+        notDeepProperty(obj: Object, prop: string, msg?: string): PromiseLike<void>;
 
-        propertyVal(obj: Object, prop: string, val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        propertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        propertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
 
-        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): PromisesAPlus.Thenable<void>;
-        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        deepPropertyVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
+        deepPropertyNotVal(obj: Object, prop: string, val: any, msg?: string): PromiseLike<void>;
 
-        lengthOf(exp: any, len: number, msg?: string): PromisesAPlus.Thenable<void>;
+        lengthOf(exp: any, len: number, msg?: string): PromiseLike<void>;
         //alias frenzy
-        throw(fn: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        throw(fn: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
-        throw(fn: Function, errType: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        throw(fn: Function, errType: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
+        throw(fn: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
 
-        throws(fn: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        throws(fn: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
-        throws(fn: Function, errType: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        throws(fn: Function, errType: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
+        throws(fn: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, regExp: RegExp): PromiseLike<void>;
+        throws(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        throws(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
 
-        Throw(fn: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        Throw(fn: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
-        Throw(fn: Function, errType: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        Throw(fn: Function, errType: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
+        Throw(fn: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, regExp: RegExp): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        Throw(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
 
-        doesNotThrow(fn: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        doesNotThrow(fn: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
-        doesNotThrow(fn: Function, errType: Function, msg?: string): PromisesAPlus.Thenable<void>;
-        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): PromisesAPlus.Thenable<void>;
+        doesNotThrow(fn: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, regExp: RegExp): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, msg?: string): PromiseLike<void>;
+        doesNotThrow(fn: Function, errType: Function, regExp: RegExp): PromiseLike<void>;
 
-        operator(val: any, operator: string, val2: any, msg?: string): PromisesAPlus.Thenable<void>;
-        closeTo(act: number, exp: number, delta: number, msg?: string): PromisesAPlus.Thenable<void>;
+        operator(val: any, operator: string, val2: any, msg?: string): PromiseLike<void>;
+        closeTo(act: number, exp: number, delta: number, msg?: string): PromiseLike<void>;
 
-        sameMembers(set1: any[], set2: any[], msg?: string): PromisesAPlus.Thenable<void>;
-        includeMembers(set1: any[], set2: any[], msg?: string): PromisesAPlus.Thenable<void>;
+        sameMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
+        includeMembers(set1: any[], set2: any[], msg?: string): PromiseLike<void>;
 
-        ifError(val: any, msg?: string): PromisesAPlus.Thenable<void>;
+        ifError(val: any, msg?: string): PromiseLike<void>;
     }
 }