Merge branch 'master' of https://github.com/DefinitelyTyped/DefinitelyTyped

acl/acl.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Qubo <https://github.com/tkQubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path='../node/node.d.ts'/>
 
 /// <reference path='../redis/redis.d.ts'/>

angular-es/angular-es-tests.ts

@@ -0,0 +1,157 @@
+/// <reference path="./angular-es.d.ts" />
+
+//
+//  @Component
+//
+import { Component } from 'angular-es';
+@Component({
+    selector: '',
+    template: ''
+})
+class MyComponentController {
+
+}
+
+//
+// @Config
+//
+import { Config } from 'angular-es';
+
+@Config()
+class MyConfig {
+
+}
+
+//
+// @Constant
+//
+import { Constant } from 'angular-es';
+
+@Constant('MyConstant')
+class MyConstant {
+    foo = 'foo';
+    bar = 'bar';
+}
+
+//
+// @Controller
+//
+import { Controller } from 'angular-es';
+
+@Controller('MyController')
+class MyController {
+
+}
+
+//
+// @Decorator
+//
+import { Decorator } from 'angular-es';
+
+@Decorator('MyServiceDecorator')
+class MyServiceDecorator {
+
+}
+
+//
+// @Directive
+//
+import { Directive } from 'angular-es';
+
+@Directive('MyDirective')
+class MyDirective {
+
+}
+
+//
+// @Factory
+//
+import { Factory } from 'angular-es';
+
+@Factory('MyFactory')
+class MyFactory {
+}
+
+//
+// @Filter
+//
+import { Filter } from 'angular-es';
+
+@Filter('MyFilter')
+class MyFilter {
+}
+
+//
+// @Inject
+//
+import { Inject } from 'angular-es';
+
+@Inject('fooBar')
+class MyFooService {
+
+    @Inject('bazBar')
+    myMethod(bazBar: Object) {
+    }
+
+    constructor(fooBar: Object) {
+    }
+}
+
+//
+// @InjectAsProperty
+//
+import { InjectAsProperty } from 'angular-es';
+
+@InjectAsProperty('fooBar')
+class MyFooBarService {
+    fooBar: Object;
+
+    myMethod() {
+        this.fooBar !== undefined;
+    }
+}
+
+//
+// @Module
+//
+import { Module } from 'angular-es';
+
+@Module('my.module')
+@Service('MyModuleService')
+class MyModuleService {
+}
+
+//
+// @Provider
+//
+import { Provider } from 'angular-es';
+
+@Provider('MyProvider')
+class MyProvider {
+}
+
+//
+// @Run
+//
+import { Run } from 'angular-es';
+
+@Run()
+class MyRunBlock {
+}
+
+//
+// @Service
+//
+import { Service } from 'angular-es';
+
+@Service('MyService')
+class MyService {
+}
+//
+// @Value
+//
+import { Value } from 'angular-es';
+
+@Value('MyValue')
+class MyValue {
+}

angular-es/angular-es.d.ts

@@ -0,0 +1,187 @@
+// Type definitions for angular-es v0.0.3
+// Project: https://github.com/mbutsykin/angular-es
+// Definitions by: mbutsykin <https://github.com/mbutsykin/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module 'angular-es' {
+
+    interface ClassDecorator {
+        <TFunction extends Function>(target: TFunction): TFunction|void;
+    }
+
+    interface MethodDecorator {
+        <T>(target: Object, propertyKey: string|symbol, descriptor: TypedPropertyDescriptor<T>): TypedPropertyDescriptor<T>|void;
+    }
+
+    /**
+     * Decorated target
+     */
+    interface ngESDecorator extends ClassDecorator, MethodDecorator {
+        (target: Object|Function,
+         ngName?: string,
+         ngArguments?: Array<any>,
+         ngType?: string,
+         injectAsProperty?: Array<string>): void;
+    }
+
+    /**
+     * Component interface
+     * @see https://docs.angularjs.org/guide/component
+     */
+    interface iComponent {
+        template: string,
+        selector: string,
+        controllerAs?: string,
+        require?: string,
+        templateUrl?: string,
+        transclude?: string,
+        bindings?: Object
+    }
+
+    /**
+     * Register component
+     *
+     * @param {Object<iComponent>} component - component config
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Component: (component: iComponent) => ngESDecorator;
+
+    /**
+     * Register config block
+     */
+    var Config: () => ngESDecorator;
+
+    /**
+     * Register constant
+     *
+     * @param {string} name - constant name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Constant: (name: string) => ngESDecorator;
+
+    /**
+     * Register controller
+     *
+     * @param {string} name - controller name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Controller: (name: string) => ngESDecorator;
+
+    /**
+     * Register decorator
+     *
+     * @param {string} name - provider name to decorate
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Decorator: (name: string) => ngESDecorator;
+
+    /**
+     * Register directive
+     *
+     * @param {string} name - directive selector, can be in hyphen-case
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Directive: (name: string) => ngESDecorator;
+
+    /**
+     * Register factory
+     *
+     * @param {string} name - factory name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Factory: (name: string) => ngESDecorator;
+
+    /**
+     * Register filter
+     *
+     * @param {string} name - filter name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Filter: (name: string) => ngESDecorator;
+
+    /**
+     * Add $inject property to target
+     *
+     * @param {Array<string>} dependencies - dependencies to inject
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Inject: (...dependencies: Array<string>) => ngESDecorator;
+
+    /**
+     * Inject dependencies as properties to target
+     *
+     * @param {Array<string>} dependencies - dependencies to inject
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var InjectAsProperty: (...dependencies: Array<string>) => ngESDecorator;
+
+    /**
+     * Attach target to the specified module
+     *
+     * @param {string} name - module name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Module: (name: string) => ngESDecorator;
+
+    /**
+     * Register provider
+     *
+     * @param {string} name - provider name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Provider: (name: string) => ngESDecorator;
+
+    /**
+     * Register run block
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Run: () => ngESDecorator;
+
+    /**
+     * Register service
+     *
+     * @param {string} name - service name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Service: (name: string) => ngESDecorator;
+
+    /**
+     * Register value
+     *
+     * @param {string} name - value name
+     *
+     * @returns {ngESDecorator} - decorated class
+     */
+    var Value: (name: string) => ngESDecorator;
+
+    export {
+        Component,
+        Config,
+        Constant,
+        Controller,
+        Decorator,
+        Directive,
+        Factory,
+        Filter,
+        Inject,
+        InjectAsProperty,
+        Module,
+        Provider,
+        Run,
+        Service,
+        Value,
+    }
+}

angularjs/angular-component-router.d.ts

@@ -476,7 +476,7 @@ declare namespace angular {
     // Supplement IComponentOptions from angular.d.ts with router-specific
     // fields.
     interface IComponentOptions {
-      $canActivate?: () => boolean;
+      $canActivate?: (...args: any[]) => boolean | angular.IPromise<boolean>;
       $routeConfig?: RouteDefinition[];
     }
 }

angularjs/angular.d.ts

@@ -238,6 +238,7 @@ declare namespace angular {
          * @param directiveFactory An injectable directive factory function.
          */
         directive(name: string, inlineAnnotatedFunction: any[]): IModule;
+        directive(name: string, injectionFunction: Function): IModule;
         directive(object: Object): IModule;
         /**
          * Register a service factory, which will be called to return the service instance. This is short for registering a service where its provider consists of only a $get property, which is the given service factory function. You should use $provide.factory(getFn) if you do not need to configure your service in a provider.
@@ -1825,7 +1826,7 @@ declare namespace angular {
         bindToController?: boolean | Object;
         link?: IDirectiveLinkFn | IDirectivePrePost;
         multiElement?: boolean;
-        name?: string;
+        directiveName?: string;
         priority?: number;
         /**
          * @deprecated

anydb-sql-migrations/anydb-sql-migrations.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Gorgi Kosev <https://github.com/spion>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path="../anydb-sql/anydb-sql.d.ts" />
 
 declare module "anydb-sql-migrations" {
@@ -31,4 +31,4 @@ declare module "anydb-sql-migrations" {
             items: MigrationTask[];
         }) => any) => Promise<any>;
     };
-}
+}

asana/asana.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path="../request/request.d.ts" />
 
 declare module "asana" {

auth0-js/auth0-js-tests.ts

@@ -0,0 +1,23 @@
+/// <reference path="auth0-js.d.ts" />
+
+var auth0 = new Auth0({
+    domain: 'mine.auth0.com',
+    clientID: 'dsa7d77dsa7d7',
+    callbackURL: 'http://my-app.com/callback',
+    callbackOnLocationHash: true
+});
+
+auth0.login({
+    connection: 'google-oauth2',
+    popup: true,
+    popupOptions: {
+        width: 450,
+        height: 800
+    }
+}, (err, profile, idToken, accessToken, state) => {
+        if (err) {
+            alert("something went wrong: " + err.message);
+            return;
+        }
+        alert('hello ' + profile.name);
+    });

auth0-js/auth0-js.d.ts

@@ -0,0 +1,132 @@
+// Type definitions for Auth0.js
+// Project: https://github.com/auth0/auth0.js
+// Definitions by: Robert McLaws <https://github.com/advancedrei>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/** Extensions to the browser Window object. */
+interface Window {
+    /** Allows you to pass the id_token to other APIs, as specified in https://docs.auth0.com/apps-apis */
+    token: string;
+}
+
+/** This is the interface for the main Auth0 client. */
+interface Auth0Static {
+
+    new(options: Auth0ClientOptions): Auth0Static;
+    changePassword(options: any, callback?: Function): void;
+    decodeJwt(jwt: string): any;
+    login(options: any, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
+    loginWithPopup(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
+    loginWithResourceOwner(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: any) => any): void;
+    loginWithUsernamePassword(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
+    logout(query: string): void;
+    getConnections(callback?: Function): void;
+    refreshToken(refreshToken: string, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
+    getDelegationToken(targetClientId: string, id_token: string, options: any, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
+    getProfile(id_token: string, callback?: Function): Auth0UserProfile;
+    getSSOData(withActiveDirectories: any, callback?: Function): void;
+    parseHash(hash: string): Auth0DecodedHash;
+    signup(options: Auth0SignupOptions, callback: Function): void;
+    validateUser(options: any, callback: (error?: Auth0Error, valid?: any) => any): void;
+}
+
+/** Represents constructor options for the Auth0 client. */
+interface Auth0ClientOptions {
+    clientID: string;
+    callbackURL: string;
+    callbackOnLocationHash?: boolean;
+    domain: string;
+    forceJSONP?: boolean;
+}
+
+/** Represents a normalized UserProfile. */
+interface Auth0UserProfile {
+    email: string;
+    family_name: string;
+    gender: string;
+    given_name: string;
+    locale: string;
+    name: string;
+    nickname: string;
+    picture: string;
+    user_id: string;
+    /** Represents one or more Identities that may be associated with the User. */
+    identities: Auth0Identity[];
+    user_metadata?: any;
+    app_metadata?: any;
+}
+
+/** Represents an Auth0UserProfile that has a Microsoft Account as the primary identity. */
+interface MicrosoftUserProfile extends Auth0UserProfile {
+    emails: string[];
+}
+
+/** Represents an Auth0UserProfile that has an Office365 account as the primary identity. */
+interface Office365UserProfile extends Auth0UserProfile {
+    tenantid: string;
+    upn: string;
+}
+
+/** Represents an Auth0UserProfile that has an Active Directory account as the primary identity. */
+interface AdfsUserProfile extends Auth0UserProfile {
+    issuer: string;
+}
+
+/** Represents multiple identities assigned to a user. */
+interface Auth0Identity {
+    access_token: string;
+    connection: string;
+    isSocial: boolean;
+    provider: string;
+    user_id: string;
+}
+
+interface Auth0DecodedHash {
+    access_token: string;
+    id_token: string;
+    profile: Auth0UserProfile;
+    state: any;
+}
+
+interface Auth0PopupOptions {
+    width: number;
+    height: number;
+}
+
+interface Auth0LoginOptions {
+    auto_login?: boolean;
+    connection?: string;
+    email?: string;
+    username?: string;
+    password?: string;
+    popup?: boolean;
+    popupOptions?: Auth0PopupOptions;
+}
+
+interface Auth0SignupOptions extends Auth0LoginOptions {
+    auto_login: boolean;
+}
+
+interface Auth0Error {
+    code: any;
+    details: any;
+    name: string;
+    message: string;
+    status: any;
+}
+
+/** Represents the response from an API Token Delegation request. */
+interface Auth0DelegationToken {
+    /** The length of time in seconds the token is valid for. */
+    expires_in: string;
+    /** The JWT for delegated access.  */
+    id_token: string;
+    /** The type of token being returned. Possible values: "Bearer"  */
+    token_type: string;
+}
+
+declare var Auth0: Auth0Static;
+
+declare module "auth0" {
+    export = Auth0
+}

auth0.lock/auth0.lock-tests.ts

@@ -1,4 +1,4 @@
-/// <reference path="../auth0/auth0.d.ts" />
+/// <reference path="../auth0-js/auth0-js.d.ts" />
 /// <reference path="auth0.lock.d.ts" />
 
 const CLIENT_ID = "YOUR_AUTH0_APP_CLIENTID";

auth0.lock/auth0.lock.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Brian Caruso <https://github.com/carusology>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../auth0/auth0.d.ts" />
+/// <reference path="../auth0-js/auth0-js.d.ts" />
 
 interface Auth0LockAdditionalSignUpFieldOption {
   value: string;

auth0.widget/auth0.widget-tests.ts

@@ -1,4 +1,4 @@
-/// <reference path="../auth0/auth0.d.ts" />
+/// <reference path="../auth0-js/auth0-js.d.ts" />
 /// <reference path="auth0.widget.d.ts" />
 
 var widget: Auth0WidgetStatic = new Auth0Widget({

auth0.widget/auth0.widget.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Robert McLaws <https://github.com/advancedrei>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../auth0/auth0.d.ts" />
+/// <reference path="../auth0-js/auth0-js.d.ts" />
 
 
 interface Auth0WidgetStatic {

auth0/auth0-tests.ts

@@ -1,23 +1,51 @@
-/// <reference path="../auth0/auth0.d.ts" />
+/// <reference path="auth0.d.ts" />
 
-var auth0 = new Auth0({
-    domain: 'mine.auth0.com',
-    clientID: 'dsa7d77dsa7d7',
-    callbackURL: 'http://my-app.com/callback',
-    callbackOnLocationHash: true
+import * as auth0 from 'auth0';
+
+const management = new auth0.ManagementClient({
+  token: '{YOUR_API_V2_TOKEN}',
+  domain: '{YOUR_ACCOUNT}.auth0.com'
 });
 
-auth0.login({
-    connection: 'google-oauth2',
-    popup: true,
-    popupOptions: {
-        width: 450,
-        height: 800
-    }
-}, (err, profile, idToken, accessToken, state) => {
-        if (err) {
-            alert("something went wrong: " + err.message);
-            return;
-        }
-        alert('hello ' + profile.name);
-    });
+const auth = new auth0.AuthenticationClient({
+  domain: '{YOUR_ACCOUNT}.auth0.com',
+  clientId: '{OPTIONAL_CLIENT_ID}'
+});
+
+// Using a callback.
+management.getUsers((err: Error, users: auth0.User[]) => {
+  if (err) {
+    // Handle error.
+  }
+  console.log(users);
+});
+
+// Using a Promise.
+management
+  .getUsers()
+  .then((users) => {
+    console.log(users);
+  })
+  .catch((err) => {
+    // Handle the error.
+  });
+
+management
+  .createUser({
+    connection: 'My-Connection',
+    email: 'hi@me.co',
+  }).then((user) => {
+    console.log(user);
+  }).catch((err) => {
+    // Handle the error.
+  });
+
+auth
+  .requestChangePasswordEmail({
+    connection: 'My-Connection',
+    email: 'hi@me.co',
+  }).then((response) => {
+    console.log(response);
+  }).catch((err) => {
+    // Handle the error.
+  });

auth0/auth0.d.ts

@@ -1,131 +1,95 @@
-// Type definitions for Auth0.js
-// Project: http://auth0.com
-// Definitions by: Robert McLaws <https://github.com/advancedrei>
+// Type definitions for auth0 v2.3.1
+// Project: https://github.com/auth0/node-auth0
+// Definitions by: Seth Westphal <https://github.com/westy92>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/** Extensions to the browser Window object. */
-interface Window {
-    /** Allows you to pass the id_token to other APIs, as specified in https://docs.auth0.com/apps-apis */
+/// <reference path="../bluebird/bluebird.d.ts" />
+
+declare module "auth0" {
+
+  import * as Promise from 'bluebird';
+
+  export interface ManagementClientOptions {
     token: string;
-}
+    domain?: string;
+  }
 
-/** This is the interface for the main Auth0 client. */
-interface Auth0Static {
-
-    new(options: Auth0ClientOptions): Auth0Static;
-    changePassword(options: any, callback?: Function): void;
-    decodeJwt(jwt: string): any;
-    login(options: any, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
-    loginWithPopup(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
-    loginWithResourceOwner(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: any) => any): void;
-    loginWithUsernamePassword(options: Auth0LoginOptions, callback: (error?: Auth0Error, profile?: Auth0UserProfile, id_token?: string, access_token?: string, state?: string) => any): void;
-    logout(query: string): void;
-    getConnections(callback?: Function): void;
-    getDelegationToken(targetClientId: string, id_token: string, options: any, callback: (error?: Auth0Error, delegationResult?: Auth0DelegationToken) => any): void;
-    getProfile(id_token: string, callback?: Function): Auth0UserProfile;
-    getSSOData(withActiveDirectories: any, callback?: Function): void;
-    parseHash(hash: string): Auth0DecodedHash;
-    signup(options: Auth0SignupOptions, callback: Function): void;
-    validateUser(options: any, callback: (error?: Auth0Error, valid?: any) => any): void;
-}
-
-/** Represents constructor options for the Auth0 client. */
-interface Auth0ClientOptions {
-    clientID: string;
-    callbackURL: string;
-    callbackOnLocationHash?: boolean;
-    domain: string;
-    forceJSONP?: boolean;
-}
-
-/** Represents a normalized UserProfile. */
-interface Auth0UserProfile {
-    email: string;
-    family_name: string;
-    gender: string;
-    given_name: string;
-    locale: string;
-    name: string;
-    nickname: string;
-    picture: string;
-    user_id: string;
-    /** Represents one or more Identities that may be associated with the User. */
-    identities: Auth0Identity[];
-    user_metadata?: any;
-    app_metadata?: any;
-}
-
-/** Represents an Auth0UserProfile that has a Microsoft Account as the primary identity. */
-interface MicrosoftUserProfile extends Auth0UserProfile {
-    emails: string[];
-}
-
-/** Represents an Auth0UserProfile that has an Office365 account as the primary identity. */
-interface Office365UserProfile extends Auth0UserProfile {
-    tenantid: string;
-    upn: string;
-}
-
-/** Represents an Auth0UserProfile that has an Active Directory account as the primary identity. */
-interface AdfsUserProfile extends Auth0UserProfile {
-    issuer: string;
-}
-
-/** Represents multiple identities assigned to a user. */
-interface Auth0Identity {
-    access_token: string;
+  export interface UserData {
     connection: string;
-    isSocial: boolean;
-    provider: string;
-    user_id: string;
-}
-
-interface Auth0DecodedHash {
-    access_token: string;
-    id_token: string;
-    profile: Auth0UserProfile;
-    state: any;
-}
-
-interface Auth0PopupOptions {
-    width: number;
-    height: number;
-}
-
-interface Auth0LoginOptions {
-    auto_login?: boolean;
-    connection?: string;
     email?: string;
     username?: string;
     password?: string;
-    popup?: boolean;
-    popupOptions?: Auth0PopupOptions;
-}
+    phone_number?: string;
+    user_metadata?: {};
+    email_verified?: boolean;
+    app_metadata?: {};
+  }
 
-interface Auth0SignupOptions extends Auth0LoginOptions {
-    auto_login: boolean;
-}
+  export interface GetUsersData {
+    per_page?: number;
+    page?: number;
+    include_totals?: boolean;
+    sort?: string;
+    connection?: string;
+    fields?: string;
+    include_fields?: boolean;
+    q?: string;
+    search_engine?: string;
+  }
 
-interface Auth0Error {
-    code: any;
-    details: any;
-    name: string;
-    message: string;
-    status: any;
-}
+  export interface User {
+    email?: string;
+    email_verified?: boolean;
+    username?: string;
+    phone_number?: string;
+    phone_verified?: boolean;
+    user_id?: string;
+    created_at?: string;
+    updated_at?: string;
+    identities?: Identity[];
+    app_metadata?: {};
+    user_metadata?: {};
+    picture?: string;
+    name?: string;
+    nickname?: string;
+    multifactor?: string[];
+    last_ip?: string;
+    last_login?: string;
+    logins_count?: number;
+    blocked?: boolean;
+  }
 
-/** Represents the response from an API Token Delegation request. */
-interface Auth0DelegationToken {
-    /** The length of time in seconds the token is valid for. */
-    expires_in: string;
-    /** The JWT for delegated access.  */
-    id_token: string;
-    /** The type of token being returned. Possible values: "Bearer"  */
-    token_type: string;
-}
+  export interface Identity {
+    connection: string;
+    user_id: string;
+    provider: string;
+    isSocial: boolean;
+  }
 
-declare var Auth0: Auth0Static;
+  export class ManagementClient {
+    constructor(options: ManagementClientOptions);
+
+    getUsers(params?: GetUsersData): Promise<User[]>;
+    getUsers(params?: GetUsersData, cb?: (err: Error, users: User[]) => void): void;
+    createUser(data: UserData): Promise<User>;
+    createUser(data: UserData, cb: (err: Error, data: User) => void): void;
+  }
+
+  export interface AuthenticationClientOptions {
+    clientId?: string;
+    domain: string;
+  }
+
+  export interface RequestChangePasswordEmailData {
+    connection: string;
+    email: string;
+  }
+
+  export class AuthenticationClient {
+    constructor(options: AuthenticationClientOptions);
+
+    requestChangePasswordEmail(data: RequestChangePasswordEmailData): Promise<string>;
+    requestChangePasswordEmail(data: RequestChangePasswordEmailData, cb: (err: Error, message: string) => void): void;
+  }
 
-declare module "auth0" {
-    export = Auth0
 }

aws-lambda/aws-lambda-tests.ts

@@ -9,6 +9,8 @@ var kinesis: lambda.Kinesis;
 var recordsList: lambda.Record[];
 var anyObj: any;
 var num: number;
+var identity: lambda.Identity;
+var error: Error;
 
 /* Records */
 var records: lambda.Records;
@@ -46,4 +48,19 @@ context.succeed(str);
 context.succeed(anyObj);
 context.succeed(str, anyObj);
 str = context.awsRequestId;
-num = context.getRemainingTimeInMillis();
+num = context.getRemainingTimeInMillis();
+identity = context.identity;
+
+/* Identity */
+var identity: lambda.Identity;
+
+str = identity.cognitoIdentityId;
+str = identity.cognitoIdentityPoolId;
+
+/* Callback */
+function callback(cb: lambda.Callback) {
+    cb();
+    cb(null);
+    cb(error);
+    cb(null, anyObj);
+}

aws-lambda/aws-lambda.d.ts

@@ -36,8 +36,20 @@ declare module "aws-lambda" {
         succeed(message: string, object: any): void;
         awsRequestId: string;
         getRemainingTimeInMillis(): number;
+        /** Information about the Amazon Cognito identity provider when invoked through the AWS Mobile SDK. It can be null. */
+        identity?: Identity;
     }
 
+    interface Identity {
+        cognitoIdentityId: string;
+        cognitoIdentityPoolId: string;
+    }
 
-    export type Callback = (error?: Error, message?: string) => void;
+    /**
+     * Optional callback parameter.
+     *
+     *  @param error – an optional parameter that you can use to provide results of the failed Lambda function execution.
+     *  @param result – an optional parameter that you can use to provide the result of a successful function execution. The result provided must be JSON.stringify compatible.
+     */
+    export type Callback = (error?: Error, result?: any) => void;
 }

base64url/base64url.d.ts

@@ -0,0 +1,74 @@
+// Type definitions for base64url v2.0.0
+// Project: https://github.com/brianloveswords/base64url
+// Definitions by: Stepan Miroshin <https://github.com/microshine>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+/**
+ * For encoding and decoding base64url!
+ * v2.0.0
+ */
+
+/**
+ * Encoding type
+ */
+declare type Encoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "utf16le" | "base64" | "binary" | "hex"
+
+interface IBase64Url {
+    /**
+     * Encode input to base64url
+     * @param {string} input Incoming input 
+     * @param {Encoding} encoding Default 'utf8'
+     * @return {string} 
+     */
+    (input: string, encoding?: Encoding): string;
+    /**
+     * Encode input to base64url
+     * @param {Buffer} input Incoming value 
+     */
+    (inout: Buffer): string;
+    /**
+     * Encode input to base64url
+     * 
+     * @param {string} input Incoming input 
+     * @param {Encoding} encoding Default 'utf8'
+     * @returns {string}
+     */
+    encode(input: string, encoding?: Encoding): string;
+    /**
+     * Encode input to base64url
+     * @param {Buffer} input Incoming value 
+     */
+    encode(input: Buffer): string;
+    /**
+     * Convert a base64url encoded string into a raw string.
+     * @param {string} base64url base64url encoded string 
+     * @param {Encoding} encoding Encoding defaults to 'utf8'
+     * @returns {string}
+     */
+    decode(base64url: string, encoding?: string): string;
+    /**
+     * Convert a base64url encoded string to a base64 encoded string
+     * @param {string | Buffer} base64url base64url encoded value 
+     * @returns {string}
+     */
+    toBase64(base64url: string | Buffer): string;
+    /**
+     * Convert a base64 encoded string to a base64url encoded string
+     * @param {string} base64 encoded string
+     * @returns {string}
+     */
+    fromBase64(base64: string): string;
+    /**
+     * Convert a base64url encoded string to a Buffer
+     * @param {string} base64url encoded string 
+     * @returns {Buffer}
+     */
+    toBuffer(base64url: string): Buffer;
+}
+
+declare module "base64url" {
+    const base64url: IBase64Url;
+    export = base64url;
+}

base64url/base64url.test.ts

@@ -0,0 +1,26 @@
+/// <reference path="./base64url.d.ts" />
+
+import * as base64url from "base64url";
+
+// default
+let str = base64url("some value");
+str = base64url("some value", "hex");
+str = base64url(new Buffer("some value"));
+
+// encode
+str = base64url.encode("some value");
+str = base64url.encode("some value", "hex");
+str = base64url.encode(new Buffer("some value"));
+
+// decode
+str = base64url.decode("ADA=");
+str = base64url.decode("ADA=", "binary");
+
+// toBase64
+str = base64url.toBase64("ADA=");
+str = base64url.toBase64(new Buffer("ADA=", "base64"));
+
+// fromBase64
+str = base64url.fromBase64("ADA=");
+
+let buf = base64url.toBase64("ADA=");

big.js/big.js-tests.ts

@@ -12,6 +12,7 @@
   
 */
 
+import BigJS = BigJsLibrary.BigJS;
 function constructorTests() {
     var x = new Big(9)                       // '9'
     var y = new Big(x)                       // '9'
@@ -247,4 +248,19 @@ function testMultipleConstructors() {
 
 	x.div(3)     // 1.667
 	y.div(3)     // 1.6666666667
-}
+}
+
+function multipleTypesAccepted(n: number | BigJS | string) {
+  var y = Big(n)
+    .minus(n)
+    .mod(n)
+    .plus(n)
+    .times(n);
+  y.cmp(n);
+  y.eq(n);
+  y.gt(n);
+  y.gte(n);
+  y.lt(n);
+  y.lte(n);
+  y.div(n)
+}

big.js/big.js.d.ts

@@ -25,23 +25,11 @@ declare namespace BigJsLibrary {
         RM: RoundingMode;
     }
 
+    type BigNumberInputType = number | string | BigJS;
+
     interface BigJS_Constructors {
-        /** A decimal value.  */
-        new (value: number): BigJS;
-        /** A decimal value.
-            String values may be in exponential, as well as normal (non-exponential) notation. There is no limit to the number of digits of a string value (other than that of Javascript's maximum array size), but the largest recommended exponent magnitude is 1e+6. Infinity, NaN and hexadecimal literal strings, e.g. '0xff', are not valid.
-            String values in octal literal form will be interpreted as decimals, e.g. '011' is 11, not 9. */
-        new (value: string): BigJS;
-        /** A decimal value.  */
-        new (value: BigJS): BigJS;
-        /** A decimal value.  */
-        (value: number): BigJS;
-        /** A decimal value.
-            String values may be in exponential, as well as normal (non-exponential) notation. There is no limit to the number of digits of a string value (other than that of Javascript's maximum array size), but the largest recommended exponent magnitude is 1e+6. Infinity, NaN and hexadecimal literal strings, e.g. '0xff', are not valid.
-            String values in octal literal form will be interpreted as decimals, e.g. '011' is 11, not 9. */
-        (value: string): BigJS;
-        /** A decimal value.  */
-        (value: BigJS): BigJS;
+        new (value: BigNumberInputType): BigJS;
+        (value: BigNumberInputType): BigJS;
 
 		/** A decimal value.  */
         (): BigJS;
@@ -57,85 +45,35 @@ declare namespace BigJsLibrary {
              1 = If the value of this Big number is greater than the value of n
             -1 = If the value of this Big number is less than the value of n
              0 = If this Big number and n have the same value */
-        cmp(n: number): number;
-        /** Compare
-            @returns {Number}
-             1 = If the value of this Big number is greater than the value of n
-            -1 = If the value of this Big number is less than the value of n
-             0 = If this Big number and n have the same value */
-        cmp(n: string): number;
-        /** Compare
-            @returns {Number}
-             1 = If the value of this Big number is greater than the value of n
-            -1 = If the value of this Big number is less than the value of n
-             0 = If this Big number and n have the same value */
-        cmp(n: BigJS): number;
+        cmp(n: BigNumberInputType): number;
 
         /** Returns a Big number whose value is the value of this Big number divided by n.  */
-        div(n: number): BigJS;
-        /** Returns a Big number whose value is the value of this Big number divided by n.  */
-        div(n: string): BigJS;
-        /** Returns a Big number whose value is the value of this Big number divided by n.  */
-        div(n: BigJS): BigJS;
+        div(n: BigNumberInputType): BigJS;
 
         /** Returns true if the value of this Big equals the value of n, otherwise returns false.  */
-        eq(n: number): boolean;
-        /** Returns true if the value of this Big equals the value of n, otherwise returns false.  */
-        eq(n: string): boolean;
-        /** Returns true if the value of this Big equals the value of n, otherwise returns false.  */
-        eq(n: BigJS): boolean;
+        eq(n: BigNumberInputType): boolean;
 
         /** Returns true if the value of this Big is greater than the value of n, otherwise returns false.  */
-        gt(n: number): boolean;
-        /** Returns true if the value of this Big is greater than the value of n, otherwise returns false.  */
-        gt(n: string): boolean;
-        /** Returns true if the value of this Big is greater than the value of n, otherwise returns false.  */
-        gt(n: BigJS): boolean;
+        gt(n: BigNumberInputType): boolean;
 
         /** Returns true if the value of this Big is greater than or equal to the value of n, otherwise returns false.  */
-        gte(n: number): boolean;
-        /** Returns true if the value of this Big is greater than or equal to the value of n, otherwise returns false.  */
-        gte(n: string): boolean;
-        /** Returns true if the value of this Big is greater than or equal to the value of n, otherwise returns false.  */
-        gte(n: BigJS): boolean;
+        gte(n: BigNumberInputType): boolean;
 
         /** Returns true if the value of this Big is less than the value of n, otherwise returns false.  */
-        lt(n: number): boolean;
-        /** Returns true if the value of this Big is less than the value of n, otherwise returns false.  */
-        lt(n: string): boolean;
-        /** Returns true if the value of this Big is less than the value of n, otherwise returns false.  */
-        lt(n: BigJS): boolean;
+        lt(n: BigNumberInputType): boolean;
 
         /** Returns true if the value of this Big is less than or equal to the value of n, otherwise returns false.  */
-        lte(n: number): boolean;
-        /** Returns true if the value of this Big is less than or equal to the value of n, otherwise returns false.  */
-        lte(n: string): boolean;
-        /** Returns true if the value of this Big is less than or equal to the value of n, otherwise returns false.  */
-        lte(n: BigJS): boolean;
+        lte(n: BigNumberInputType): boolean;
 
         /** Returns a Big number whose value is the value of this Big number minus n.  */
-        minus(n: number): BigJS;
-        /** Returns a Big number whose value is the value of this Big number minus n.  */
-        minus(n: string): BigJS;
-        /** Returns a Big number whose value is the value of this Big number minus n.  */
-        minus(n: BigJS): BigJS;
+        minus(n: BigNumberInputType): BigJS;
 
         /** Returns a Big number whose value is the value of this Big number modulo n, i.e. the integer remainder of dividing this Big number by n.
-            The result will have the same sign as this Big number, and it will match that of Javascript's % operator (within the limits of its precision) and BigDecimal's remainder method. */
-        mod(n: number): BigJS;
-        /** Returns a Big number whose value is the value of this Big number modulo n, i.e. the integer remainder of dividing this Big number by n.
-            The result will have the same sign as this Big number, and it will match that of Javascript's % operator (within the limits of its precision) and BigDecimal's remainder method. */
-        mod(n: string): BigJS;
-        /** Returns a Big number whose value is the value of this Big number modulo n, i.e. the integer remainder of dividing this Big number by n.
-            The result will have the same sign as this Big number, and it will match that of Javascript's % operator (within the limits of its precision) and BigDecimal's remainder method. */
-        mod(n: BigJS): BigJS;
+         The result will have the same sign as this Big number, and it will match that of Javascript's % operator (within the limits of its precision) and BigDecimal's remainder method. */
+        mod(n: BigNumberInputType): BigJS;
 
         /** Returns a Big number whose value is the value of this Big number plus n.  */
-        plus(n: number): BigJS;
-        /** Returns a Big number whose value is the value of this Big number plus n.  */
-        plus(n: string): BigJS;
-        /** Returns a Big number whose value is the value of this Big number plus n.  */
-        plus(n: BigJS): BigJS;
+        plus(n: BigNumberInputType): BigJS;
 
         /** Returns a Big number whose value is the value of this Big number raised to the power exp.
             If exp is negative and the result has more fraction digits than is specified by Big.DP, it will be rounded to Big.DP decimal places using rounding mode Big.RM.
@@ -156,11 +94,7 @@ declare namespace BigJsLibrary {
         sqrt(): BigJS;
 
         /** Returns a Big number whose value is the value of this Big number times n.  */
-        times(n: number): BigJS;
-        /** Returns a Big number whose value is the value of this Big number times n.  */
-        times(n: string): BigJS;
-        /** Returns a Big number whose value is the value of this Big number times n.  */
-        times(n: BigJS): BigJS;
+        times(n: BigNumberInputType): BigJS;
 
         /** Returns a string representing the value of this Big number in exponential notation to a fixed number of decimal places dp.    */
         toExponential(): string;

blessed/blessed-tests.ts

@@ -0,0 +1,773 @@
+///<reference path="blessed.d.ts" />
+
+import * as blessed from 'blessed';
+
+let screen: blessed.Widgets.Screen = null;
+
+// https://github.com/chjj/blessed/blob/master/test/widget-autopad.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/autopad.log',
+  smartCSR: true,
+  autoPadding: true,
+  warnings: true
+});
+
+var box1 = blessed.box({
+  parent: screen,
+  top: 'center',
+  left: 'center',
+  width: 20,
+  height: 10,
+  border: 'line'
+});
+
+var box2 = blessed.box({
+  parent: box1,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line'
+});
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+screen.render();
+
+// https://github.com/chjj/blessed/blob/master/test/widget-bigtext.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/bigtext.log',
+  smartCSR: true,
+  warnings: true
+});
+
+var box = blessed.bigtext({
+  parent: screen,
+  content: 'Hello',
+  shrink: true,
+  width: '80%',
+  // height: '80%',
+  height: 'shrink',
+  // width: 'shrink',
+  border: 'line',
+  fch: ' ',
+  ch: '\u2592',
+  style: {
+    fg: 'red',
+    bg: 'blue',
+    bold: false
+  }
+});
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+screen.render();
+
+// https://github.com/chjj/blessed/blob/master/test/widget-csr.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/csr.log',
+  smartCSR: true,
+  warnings: true
+});
+
+var lorem = require('fs').readFileSync(__dirname + '/git.diff', 'utf8');
+
+var cleanSides = screen.cleanSides;
+function expectClean(value: any) {
+  screen.cleanSides = function(el: blessed.widget.Element) {
+    var ret = cleanSides.apply(this, arguments);
+    if (ret !== value) {
+      throw new Error('Failed. Expected '
+        + value + ' from cleanSides. Got '
+        + ret + '.');
+    }
+    return ret;
+  };
+}
+var btext = blessed.box({
+  parent: screen,
+  left: 'center',
+  top: 'center',
+  width: '80%',
+  height: '80%',
+  style: {
+    bg: 'green'
+  },
+  border: 'line',
+  content: 'CSR should still work.'
+});
+let _oscroll = btext.scroll;
+btext.scroll = function(offset, always) {
+  expectClean(true);
+  return _oscroll(offset, always);
+};
+
+var text = blessed.scrollabletext({
+  parent: screen,
+  content: lorem,
+  border: 'line',
+  left: 'center',
+  top: 'center',
+  draggable: true,
+  width: '50%',
+  height: '50%',
+  mouse: true,
+  keys: true,
+  vi: true
+});
+
+_oscroll = text.scroll;
+text.scroll = function(offset, always) {
+  var el = this;
+  var value = true;
+  if (el.left < 0) value = true;
+  if (el.top < 0) value = false;
+  if (el.left + el.width > screen.width) value = true;
+  if (el.top + el.height > screen.height) value = false;
+  expectClean(value);
+  return _oscroll(offset, always);
+};
+
+text.focus();
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+screen.render();
+
+// https://github.com/chjj/blessed/blob/master/test/widget-dock-noborder.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/dock.log',
+  smartCSR: true,
+  dockBorders: true,
+  warnings: true
+});
+
+blessed.box({
+  parent: screen,
+  left: -1,
+  top: -1,
+  width: '50%+1',
+  height: '50%+1',
+  border: 'line',
+  content: 'Foo'
+});
+
+blessed.box({
+  parent: screen,
+  left: '50%-1',
+  top: -1,
+  width: '50%+3',
+  height: '50%+1',
+  content: 'Bar',
+  border: 'line'
+});
+
+blessed.box({
+  parent: screen,
+  left: -1,
+  top: '50%-1',
+  width: '50%+1',
+  height: '50%+3',
+  border: 'line',
+  content: 'Foo'
+});
+
+blessed.listtable({
+  parent: screen,
+  left: '50%-1',
+  top: '50%-1',
+  width: '50%+3',
+  height: '50%+3',
+  border: 'line',
+  align: 'center',
+  tags: true,
+  keys: true,
+  vi: true,
+  mouse: true,
+  style: {
+    header: {
+      fg: 'blue',
+      bold: true
+    },
+    cell: {
+      fg: 'magenta',
+      selected: {
+        bg: 'blue'
+      }
+    }
+  },
+  data: [
+    [ 'Animals',  'Foods',  'Times',   'Numbers' ],
+    [ 'Elephant', 'Apple',  '1:00am',  'One'     ],
+    [ 'Bird',     'Orange', '2:15pm',  'Two'     ],
+    [ 'T-Rex',    'Taco',   '8:45am',  'Three'   ],
+    [ 'Mouse',    'Cheese', '9:05am',  'Four'    ]
+  ]
+}).focus();
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+screen.render();
+
+// https://raw.githubusercontent.com/chjj/blessed/master/example/simple-form.js
+
+var form = blessed.form({
+  parent: screen,
+  keys: true,
+  left: 0,
+  top: 0,
+  width: 30,
+  height: 4,
+  bg: 'green',
+  content: 'Submit or cancel?'
+});
+
+var submit = blessed.button({
+  parent: form,
+  mouse: true,
+  keys: true,
+  padding: {
+    left: 1,
+    right: 1
+  },
+  left: 10,
+  top: 2,
+  shrink: true,
+  name: 'submit',
+  content: 'submit',
+  style: {
+    bg: 'blue',
+    focus: {
+      bg: 'red'
+    },
+    hover: {
+      bg: 'red'
+    }
+  }
+});
+
+var cancel = blessed.button({
+  parent: form,
+  mouse: true,
+  keys: true,
+  padding: {
+    left: 1,
+    right: 1
+  },
+  left: 20,
+  top: 2,
+  shrink: true,
+  name: 'cancel',
+  content: 'cancel',
+  style: {
+    bg: 'blue',
+    focus: {
+      bg: 'red'
+    },
+    hover: {
+      bg: 'red'
+    }
+  }
+});
+
+// https://github.com/chjj/blessed/blob/master/test/widget-layout.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/layout.log',
+  smartCSR: true,
+  autoPadding: true,
+  warnings: true
+});
+
+var layout = blessed.layout({
+  parent: screen,
+  top: 'center',
+  left: 'center',
+  width: '50%',
+  height: '50%',
+  border: 'line',
+  layout: process.argv[2] === 'grid' ? 'grid' : 'inline',
+  style: {
+    bg: 'red',
+    border: {
+      fg: 'blue'
+    }
+  }
+});
+
+var box1 = blessed.box({
+  parent: layout,
+  top: 'center',
+  left: 'center',
+  width: 20,
+  height: 10,
+  border: 'line',
+  content: '1'
+});
+
+var box2 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '2'
+});
+
+var box3 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '3'
+});
+
+var box4 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '4'
+});
+
+var box5 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '5'
+});
+
+var box6 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '6'
+});
+
+var box7 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '7'
+});
+
+var box8 = blessed.box({
+  parent: layout,
+  top: 'center',
+  left: 'center',
+  width: 20,
+  height: 10,
+  border: 'line',
+  content: '8'
+});
+
+var box9 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '9'
+});
+
+var box10 = blessed.box({
+  parent: layout,
+  top: 'center',
+  left: 'center',
+  width: 20,
+  height: 10,
+  border: 'line',
+  content: '10'
+});
+
+var box11 = blessed.box({
+  parent: layout,
+  top: 0,
+  left: 0,
+  width: 10,
+  height: 5,
+  border: 'line',
+  content: '11'
+});
+
+var box12 = blessed.box({
+  parent: layout,
+  top: 'center',
+  left: 'center',
+  width: 20,
+  height: 10,
+  border: 'line',
+  content: '12'
+});
+
+if (process.argv[2] !== 'grid') {
+  for (var i = 0; i < 10; i++) {
+    blessed.box({
+      parent: layout,
+      // width: i % 2 === 0 ? 10 : 20,
+      // height: i % 2 === 0 ? 5 : 10,
+      width: Math.random() > 0.5 ? 10 : 20,
+      height: Math.random() > 0.5 ? 5 : 10,
+      border: 'line',
+      content: (i + 1 + 12) + ''
+    });
+  }
+}
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+screen.render();
+
+// https://github.com/chjj/blessed/blob/master/test/widget-form.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/form.log',
+  warnings: true
+});
+
+type FormData = {
+    radio1: boolean;
+    radio2: boolean;
+    text: string;
+    check: boolean;
+};
+
+var form2 = blessed.form<FormData>({
+  parent: screen,
+  mouse: true,
+  keys: true,
+  vi: true,
+  left: 0,
+  top: 0,
+  width: '100%',
+  //height: 12,
+  style: {
+    bg: 'green',
+    border: {
+       inverse: true
+    },
+    scrollbar: {
+      inverse: true
+    }
+  },
+  content: 'foobar',
+  scrollable: true,
+  scrollbar: {
+    ch: ' '
+  }
+  //alwaysScroll: true
+});
+
+form2.on('submit', (data) => {
+  output.setContent(JSON.stringify(data, null, 2));
+  screen.render();
+});
+
+form2.key('d', function() {
+  form2.scroll(1, true);
+  screen.render();
+});
+
+form2.key('u', function() {
+  form2.scroll(-1, true);
+  screen.render();
+});
+
+var set = blessed.radioset({
+  parent: form2,
+  left: 1,
+  top: 1,
+  shrink: true,
+  //padding: 1,
+  //content: 'f',
+  style: {
+    bg: 'magenta'
+  }
+});
+
+var radio1 = blessed.radiobutton({
+  parent: set,
+  mouse: true,
+  keys: true,
+  shrink: true,
+  style: {
+    bg: 'magenta'
+  },
+  height: 1,
+  left: 0,
+  top: 0,
+  name: 'radio1',
+  content: 'radio1'
+});
+
+var radio2 = blessed.radiobutton({
+  parent: set,
+  mouse: true,
+  keys: true,
+  shrink: true,
+  style: {
+    bg: 'magenta'
+  },
+  height: 1,
+  left: 15,
+  top: 0,
+  name: 'radio2',
+  content: 'radio2'
+});
+
+var text2 = blessed.textbox({
+  parent: form2,
+  mouse: true,
+  keys: true,
+  style: {
+    bg: 'blue'
+  },
+  height: 1,
+  width: 20,
+  left: 1,
+  top: 3,
+  name: 'text'
+});
+
+text2.on('focus', function() {
+  text2.readInput();
+});
+
+var check = blessed.checkbox({
+  parent: form2,
+  mouse: true,
+  keys: true,
+  shrink: true,
+  style: {
+    bg: 'magenta'
+  },
+  height: 1,
+  left: 28,
+  top: 1,
+  name: 'check',
+  content: 'check'
+});
+
+var check2 = blessed.checkbox({
+  parent: form2,
+  mouse: true,
+  keys: true,
+  shrink: true,
+  style: {
+    bg: 'magenta'
+  },
+  height: 1,
+  left: 28,
+  top: 14,
+  name: 'foooooooo2',
+  content: 'foooooooo2'
+});
+
+var submit = blessed.button({
+  parent: form2,
+  mouse: true,
+  keys: true,
+  shrink: true,
+  padding: {
+    left: 1,
+    right: 1
+  },
+  left: 29,
+  top: 3,
+  name: 'submit',
+  content: 'submit',
+  style: {
+    bg: 'blue',
+    focus: {
+      bg: 'red'
+    }
+  }
+});
+
+submit.on('press', function() {
+  form2.submit();
+});
+
+var box1 = blessed.box({
+  parent: form2,
+  left: 1,
+  top: 10,
+  height: 10,
+  width: 10,
+  content: 'one',
+  style: {
+    bg: 'cyan'
+  }
+});
+
+var box2 = blessed.box({
+  parent: box1,
+  left: 1,
+  top: 2,
+  height: 8,
+  width: 9,
+  content: 'two',
+  style: {
+    bg: 'magenta'
+  }
+});
+
+var box3 = blessed.box({
+  parent: box2,
+  left: 1,
+  top: 2,
+  height: 6,
+  width: 8,
+  content: 'three',
+  style: {
+    bg: 'yellow'
+  }
+});
+
+var box4 = blessed.box({
+  parent: box3,
+  left: 1,
+  top: 2,
+  height: 4,
+  width: 7,
+  content: 'four',
+  style: {
+    bg: 'blue'
+  }
+});
+
+var output = blessed.scrollabletext({
+  parent: form2,
+  mouse: true,
+  keys: true,
+  left: 0,
+  top: 20,
+  height: 5,
+  right: 0,
+  style: {
+    bg: 'red'
+  },
+  content: 'foobar'
+});
+
+var bottom = blessed.line({
+  parent: form2,
+  type: 'line',
+  orientation: 'horizontal',
+  left: 0,
+  right: 0,
+  top: 50,
+  style: {
+    fg: 'blue'
+  }
+});
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+form2.focus();
+
+form2.submit();
+
+screen.render();
+
+// https://github.com/chjj/blessed/blob/master/test/widget-table.js
+
+screen = blessed.screen({
+  dump: __dirname + '/logs/table.log',
+  autoPadding: false,
+  fullUnicode: true,
+  warnings: true
+});
+
+var DU = '杜';
+var JUAN = '鹃';
+
+var table = blessed.table({
+  //parent: screen,
+  top: 'center',
+  left: 'center',
+  data: null,
+  border: 'line',
+  align: 'center',
+  tags: true,
+  //width: '80%',
+  width: 'shrink',
+  style: {
+    border: {
+      fg: 'red'
+    },
+    header: {
+      fg: 'blue',
+      bold: true
+    },
+    cell: {
+      fg: 'magenta'
+    }
+  }
+});
+
+var data1 = [
+  [ 'Animals',  'Foods',  'Times'  ],
+  [ 'Elephant', 'Apple',  '1:00am' ],
+  [ 'Bird',     'Orange', '2:15pm' ],
+  [ 'T-Rex',    'Taco',   '8:45am' ],
+  [ 'Mouse',    'Cheese', '9:05am' ]
+];
+
+data1[1][0] = '{red-fg}' + data1[1][0] + '{/red-fg}';
+data1[2][0] += ' (' + DU + JUAN + ')';
+
+var data2 = [
+  [ 'Animals',  'Foods',  'Times',   'Numbers' ],
+  [ 'Elephant', 'Apple',  '1:00am',  'One'     ],
+  [ 'Bird',     'Orange', '2:15pm',  'Two'     ],
+  [ 'T-Rex',    'Taco',   '8:45am',  'Three'   ],
+  [ 'Mouse',    'Cheese', '9:05am',  'Four'    ]
+];
+
+data2[1][0] = '{red-fg}' + data2[1][0] + '{/red-fg}';
+data2[2][0] += ' (' + DU + JUAN + ')';
+
+screen.key('q', function() {
+  return screen.destroy();
+});
+
+table.setData(data2);
+screen.append(table);
+screen.render();
+
+setTimeout(function() {
+  table.setData(data1);
+  screen.render();
+}, 3000);

blue-tape/blue-tape-tests.ts

@@ -1,5 +1,5 @@
 /// <reference path="../node/node.d.ts" />
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path="blue-tape.d.ts" />
 
 import tape = require('blue-tape');

bluebird-retry/bluebird-retry-tests.ts

@@ -1,5 +1,5 @@
 /// <reference path="bluebird-retry.d.ts" />
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 import Promise = require('bluebird');
 import retry = require('bluebird-retry');
 
@@ -32,4 +32,4 @@ var options:retry.Options = {
     interval: 500
 };
 
-retry(logFail, options);
+retry(logFail, options);

bluebird-retry/bluebird-retry.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Pascal Vomhoff <https://github.com/pvomhoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 declare module "bluebird-retry" {
 	import Promise = require('bluebird');
 

bluebird/bluebird-2.0.d.ts

@@ -0,0 +1,773 @@
+// Type definitions for bluebird 2.0.0
+// Project: https://github.com/petkaantonov/bluebird
+// Definitions by: Bart van der Schoor <https://github.com/Bartvds>, falsandtru <https://github.com/falsandtru>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// ES6 model with generics overload was sourced and trans-multiplied from es6-promises.d.ts
+// By: Campredon <https://github.com/fdecampredon/>
+
+// Warning: recommended to use `tsc > v0.9.7` (critical bugs in earlier generic code):
+// - https://github.com/DefinitelyTyped/DefinitelyTyped/issues/1563
+
+// Note: replicate changes to all overloads in both definition and test file
+// Note: keep both static and instance members inline (so similar)
+
+// TODO fix remaining TODO annotations in both definition and test
+
+// TODO verify support to have no return statement in handlers to get a Promise<void> (more overloads?)
+
+declare var Promise: PromiseConstructor;
+
+interface PromiseCancelHandlerSetter {
+    (handler: () => void): void;
+}
+
+interface PromiseConstructor {
+    /**
+     * Create a new promise. The passed in function will receive functions
+     * `resolve` and `reject` as its arguments which can be called to seal the
+     * fate of the created promise.
+     *
+     * If configured appropriately, it will also receive an `onCancel`
+     * function that can be used to configure a promise cancellation handler.
+     */
+    new <T>(callback: (
+        resolve: (thenableOrResult?: T | PromiseLike<T>) => void,
+        reject: (error: any) => void,
+        onCancel?: PromiseCancelHandlerSetter
+    ) => void): Promise<T>;
+    
+    config(options: {
+        warnings?: boolean | {wForgottenReturn?: boolean};
+        longStackTraces?: boolean;
+        cancellation?: boolean;
+        monitoring?: boolean;
+    }): void;
+
+    // Ideally, we'd define e.g. "export class RangeError extends Error {}",
+    // but as Error is defined as an interface (not a class), TypeScript doesn't
+    // allow extending Error, only implementing it.
+    // However, if we want to catch() only a specific error type, we need to pass
+    // a constructor function to it. So, as a workaround, we define them here as such.
+    RangeError(): RangeError;
+    CancellationError(): Promise.CancellationError;
+    TimeoutError(): Promise.TimeoutError;
+    TypeError(): Promise.TypeError;
+    RejectionError(): Promise.RejectionError;
+    OperationalError(): Promise.OperationalError;
+
+    /**
+     * Changes how bluebird schedules calls a-synchronously.
+     *
+     * @param scheduler Should be a function that asynchronously schedules
+     *                  the calling of the passed in function
+     */
+    setScheduler(scheduler: (callback: (...args: any[]) => void) => void): void;
+
+    /**
+     * Start the chain of promises with `Promise.try`. Any synchronous exceptions will be turned into rejections on the returned promise.
+     *
+     * Note about second argument: if it's specifically a true array, its values become respective arguments for the function call. Otherwise it is passed as is as the first argument for the function call.
+     *
+     * Alias for `attempt();` for compatibility with earlier ECMAScript version.
+     */
+    try<T>(fn: () => T | PromiseLike<T>, args?: any[], ctx?: any): Promise<T>;
+
+    attempt<T>(fn: () => T | PromiseLike<T>, args?: any[], ctx?: any): Promise<T>;
+
+    /**
+     * Returns a new function that wraps the given function `fn`. The new function will always return a promise that is fulfilled with the original functions return values or rejected with thrown exceptions from the original function.
+     * This method is convenient when a function can sometimes return synchronously or throw synchronously.
+     */
+    method(fn: Function): Function;
+
+    /**
+     * Create a promise that is resolved with the given `value`. If `value` is a thenable or promise, the returned promise will assume its state.
+     */
+    resolve<T>(value: T | PromiseLike<T>): Promise<T>;
+    resolve(): Promise<void>;
+
+    /**
+     * Create a promise that is rejected with the given `reason`.
+     */
+    reject(reason: any): Promise<any>;
+    reject<T>(reason: any): Promise<T>;
+
+    /**
+     * Create a promise with undecided fate and return a `PromiseResolver` to control it. See resolution?: Promise(#promise-resolution).
+     */
+    defer<T>(): Promise.Resolver<T>;
+
+    /**
+     * Cast the given `value` to a trusted promise. If `value` is already a trusted `Promise`, it is returned as is. If `value` is not a thenable, a fulfilled is: Promise returned with `value` as its fulfillment value. If `value` is a thenable (Promise-like object, like those returned by jQuery's `$.ajax`), returns a trusted that: Promise assimilates the state of the thenable.
+     */
+    cast<T>(value: T | PromiseLike<T>): Promise<T>;
+
+    /**
+     * Sugar for `Promise.resolve(undefined).bind(thisArg);`. See `.bind()`.
+     */
+    bind(thisArg: any): Promise<void>;
+
+    /**
+     * See if `value` is a trusted Promise.
+     */
+    is(value: any): boolean;
+
+    /**
+     * Call this right after the library is loaded to enabled long stack traces. Long stack traces cannot be disabled after being enabled, and cannot be enabled after promises have alread been created. Long stack traces imply a substantial performance penalty, around 4-5x for throughput and 0.5x for latency.
+     */
+    longStackTraces(): void;
+
+    /**
+     * Returns a promise that will be fulfilled with `value` (or `undefined`) after given `ms` milliseconds. If `value` is a promise, the delay will start counting down when it is fulfilled and the returned promise will be fulfilled with the fulfillment value of the `value` promise.
+     */
+    // TODO enable more overloads
+    delay<T>(ms: number, value: T | PromiseLike<T>): Promise<T>;
+    delay(ms: number): Promise<void>;
+
+    /**
+     * Returns a function that will wrap the given `nodeFunction`. Instead of taking a callback, the returned function will return a promise whose fate is decided by the callback behavior of the given node function. The node function should conform to node.js convention of accepting a callback as last argument and calling that callback with error as the first argument and success value on the second argument.
+     *
+     * If the `nodeFunction` calls its callback with multiple success values, the fulfillment value will be an array of them.
+     *
+     * If you pass a `receiver`, the `nodeFunction` will be called as a method on the `receiver`.
+     */
+    promisify<T>(func: (callback: (err: any, result: T) => void) => void, receiver?: any): () => Promise<T>;
+    promisify<T, A1>(func: (arg1: A1, callback: (err: any, result: T) => void) => void, receiver?: any): (arg1: A1) => Promise<T>;
+    promisify<T, A1, A2>(func: (arg1: A1, arg2: A2, callback: (err: any, result: T) => void) => void, receiver?: any): (arg1: A1, arg2: A2) => Promise<T>;
+    promisify<T, A1, A2, A3>(func: (arg1: A1, arg2: A2, arg3: A3, callback: (err: any, result: T) => void) => void, receiver?: any): (arg1: A1, arg2: A2, arg3: A3) => Promise<T>;
+    promisify<T, A1, A2, A3, A4>(func: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, callback: (err: any, result: T) => void) => void, receiver?: any): (arg1: A1, arg2: A2, arg3: A3, arg4: A4) => Promise<T>;
+    promisify<T, A1, A2, A3, A4, A5>(func: (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5, callback: (err: any, result: T) => void) => void, receiver?: any): (arg1: A1, arg2: A2, arg3: A3, arg4: A4, arg5: A5) => Promise<T>;
+    promisify(nodeFunction: Function, receiver?: any): Function;
+
+    /**
+     * Promisifies the entire object by going through the object's properties and creating an async equivalent of each function on the object and its prototype chain. The promisified method name will be the original method name postfixed with `Async`. Returns the input object.
+     *
+     * Note that the original methods on the object are not overwritten but new methods are created with the `Async`-postfix. For example, if you `promisifyAll()` the node.js `fs` object use `fs.statAsync()` to call the promisified `stat` method.
+     */
+    // TODO how to model promisifyAll?
+    promisifyAll(target: Object, options?: Promise.PromisifyAllOptions): any;
+
+
+    /**
+     * Returns a promise that is resolved by a node style callback function.
+     */
+    fromNode(resolver: (callback: (err: any, result?: any) => void) => void, options? : {multiArgs? : boolean}): Promise<any>;
+    fromCallback(resolver: (callback: (err: any, result?: any) => void) => void, options? : {multiArgs? : boolean}): Promise<any>;
+
+    /**
+     * Returns a function that can use `yield` to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+     */
+    // TODO fix coroutine GeneratorFunction
+    coroutine<T>(generatorFunction: Function): Function;
+
+    /**
+     * Spawn a coroutine which may yield promises to run asynchronous code synchronously. This feature requires the support of generators which are drafted in the next version of the language. Node version greater than `0.11.2` is required and needs to be executed with the `--harmony-generators` (or `--harmony`) command-line switch.
+     */
+    // TODO fix spawn GeneratorFunction
+    spawn<T>(generatorFunction: Function): Promise<T>;
+
+    /**
+     * This is relevant to browser environments with no module loader.
+     *
+     * Release control of the `Promise` namespace to whatever it was before this library was loaded. Returns a reference to the library namespace so you can attach it to something else.
+     */
+    noConflict(): typeof Promise;
+
+    /**
+     * Add `handler` as the handler to call when there is a possibly unhandled rejection. The default handler logs the error stack to stderr or `console.error` in browsers.
+     *
+     * Passing no value or a non-function will have the effect of removing any kind of handling for possibly unhandled rejections.
+     */
+    onPossiblyUnhandledRejection(handler: (reason: any) => any): void;
+
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are fulfilled. The promise's fulfillment value is an array with fulfillment values at respective positions to the original array. If any promise in the array rejects, the returned promise is rejected with the rejection reason.
+     */
+    // TODO enable more overloads
+    // promise of array with promises of value
+    all<T>(values: PromiseLike<PromiseLike<T>[]>): Promise<T[]>;
+    // promise of array with values
+    all<T>(values: PromiseLike<T[]>): Promise<T[]>;
+    // array with promises of value
+    all<T>(values: PromiseLike<T>[]): Promise<T[]>;
+    // array with promises of different types
+    all<T1, T2, T3, T4, T5>(values: [PromiseLike<T1>, PromiseLike<T2>, PromiseLike<T3>, PromiseLike<T4>, PromiseLike<T5>]): Promise<[T1, T2, T3, T4, T5]>;
+    all<T1, T2, T3, T4>(values: [PromiseLike<T1>, PromiseLike<T2>, PromiseLike<T3>, PromiseLike<T4>]): Promise<[T1, T2, T3, T4]>;
+    all<T1, T2, T3>(values: [PromiseLike<T1>, PromiseLike<T2>, PromiseLike<T3>]): Promise<[T1, T2, T3]>;
+    all<T1, T2>(values: [PromiseLike<T1>, PromiseLike<T2>]): Promise<[T1, T2]>;
+    // array with values
+    all<T>(values: T[]): Promise<T[]>;
+
+    /**
+     * Like ``Promise.all`` but for object properties instead of array items. Returns a promise that is fulfilled when all the properties of the object are fulfilled. The promise's fulfillment value is an object with fulfillment values at respective keys to the original object. If any promise in the object rejects, the returned promise is rejected with the rejection reason.
+     *
+     * If `object` is a trusted `Promise`, then it will be treated as a promise for object rather than for its properties. All other objects are treated for their properties as is returned by `Object.keys` - the object's own enumerable properties.
+     *
+     * *The original object is not modified.*
+     */
+    // TODO verify this is correct
+    // trusted promise for object
+    props(object: Promise<Object>): Promise<Object>;
+    // object
+    props(object: Object): Promise<Object>;
+
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled when all the items in the array are either fulfilled or rejected. The fulfillment value is an array of ``PromiseInspection`` instances at respective positions in relation to the input array.
+     *
+     * *original: The array is not modified. The input array sparsity is retained in the resulting array.*
+     */
+    // promise of array with promises of value
+    settle<T>(values: PromiseLike<PromiseLike<T>[]>): Promise<Promise.Inspection<T>[]>;
+    // promise of array with values
+    settle<T>(values: PromiseLike<T[]>): Promise<Promise.Inspection<T>[]>;
+    // array with promises of value
+    settle<T>(values: PromiseLike<T>[]): Promise<Promise.Inspection<T>[]>;
+    // array with values
+    settle<T>(values: T[]): Promise<Promise.Inspection<T>[]>;
+
+    /**
+     * Like `Promise.some()`, with 1 as `count`. However, if the promise fulfills, the fulfillment value is not an array of 1 but the value directly.
+     */
+    // promise of array with promises of value
+    any<T>(values: PromiseLike<PromiseLike<T>[]>): Promise<T>;
+    // promise of array with values
+    any<T>(values: PromiseLike<T[]>): Promise<T>;
+    // array with promises of value
+    any<T>(values: PromiseLike<T>[]): Promise<T>;
+    // array with values
+    any<T>(values: T[]): Promise<T>;
+
+    /**
+     * Given an array, or a promise of an array, which contains promises (or a mix of promises and values) return a promise that is fulfilled or rejected as soon as a promise in the array is fulfilled or rejected with the respective rejection reason or fulfillment value.
+     *
+     * **Note** If you pass empty array or a sparse array with no values, or a promise/thenable for such, it will be forever pending.
+     */
+    // promise of array with promises of value
+    race<T>(values: PromiseLike<PromiseLike<T>[]>): Promise<T>;
+    // promise of array with values
+    race<T>(values: PromiseLike<T[]>): Promise<T>;
+    // array with promises of value
+    race<T>(values: PromiseLike<T>[]): Promise<T>;
+    // array with values
+    race<T>(values: T[]): Promise<T>;
+
+    /**
+     * Initiate a competetive race between multiple promises or values (values will become immediately fulfilled promises). When `count` amount of promises have been fulfilled, the returned promise is fulfilled with an array that contains the fulfillment values of the winners in order of resolution.
+     *
+     * If too many promises are rejected so that the promise can never become fulfilled, it will be immediately rejected with an array of rejection reasons in the order they were thrown in.
+     *
+     * *The original array is not modified.*
+     */
+    // promise of array with promises of value
+    some<T>(values: PromiseLike<PromiseLike<T>[]>, count: number): Promise<T[]>;
+    // promise of array with values
+    some<T>(values: PromiseLike<T[]>, count: number): Promise<T[]>;
+    // array with promises of value
+    some<T>(values: PromiseLike<T>[], count: number): Promise<T[]>;
+    // array with values
+    some<T>(values: T[], count: number): Promise<T[]>;
+
+    /**
+     * Like `Promise.all()` but instead of having to pass an array, the array is generated from the passed variadic arguments.
+     */
+    // variadic array with promises of value
+    join<T>(...values: PromiseLike<T>[]): Promise<T[]>;
+    // variadic array with values
+    join<T>(...values: T[]): Promise<T[]>;
+
+    /**
+     * Map an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `mapper` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
+     *
+     * *The original array is not modified.*
+     */
+    // promise of array with promises of value
+    map<T, U>(values: PromiseLike<PromiseLike<T>[]>, mapper: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    // promise of array with values
+    map<T, U>(values: PromiseLike<T[]>, mapper: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    // array with promises of value
+    map<T, U>(values: PromiseLike<T>[], mapper: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    // array with values
+    map<T, U>(values: T[], mapper: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    /**
+     * Similar to `map` with concurrency set to 1 but guaranteed to execute in sequential order
+     *
+     * If the `mapper` function returns promises or thenables, the returned promise will wait for all the mapped results to be resolved as well.
+     *
+     * *The original array is not modified.*
+     */
+    // promise of array with promises of value
+    mapSeries<R, U>(values: PromiseLike<PromiseLike<R>[]>, mapper: (item: R, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<U[]>;
+
+    // promise of array with values
+    mapSeries<R, U>(values: PromiseLike<R[]>, mapper: (item: R, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<U[]>;
+
+    // array with promises of value
+    mapSeries<R, U>(values: PromiseLike<R>[], mapper: (item: R, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<U[]>;
+
+    // array with values
+    mapSeries<R, U>(values: R[], mapper: (item: R, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<U[]>;
+    
+
+    /**
+     * Reduce an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `reducer` function with the signature `(total, current, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * If the reducer function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
+     *
+     * *The original array is not modified. If no `intialValue` is given and the array doesn't contain at least 2 items, the callback will not be called and `undefined` is returned. If `initialValue` is given and the array doesn't have at least 1 item, `initialValue` is returned.*
+     */
+    // promise of array with promises of value
+    reduce<T, U>(values: PromiseLike<PromiseLike<T>[]>, reducer: (total: U, current: T, index: number, arrayLength: number) => U | PromiseLike<U>, initialValue?: U): Promise<U>;
+
+    // promise of array with values
+    reduce<T, U>(values: PromiseLike<T[]>, reducer: (total: U, current: T, index: number, arrayLength: number) => U | PromiseLike<U>, initialValue?: U): Promise<U>;
+
+    // array with promises of value
+    reduce<T, U>(values: PromiseLike<T>[], reducer: (total: U, current: T, index: number, arrayLength: number) => U | PromiseLike<U>, initialValue?: U): Promise<U>;
+
+    // array with values
+    reduce<T, U>(values: T[], reducer: (total: U, current: T, index: number, arrayLength: number) => U | PromiseLike<U>, initialValue?: U): Promise<U>;
+
+    /**
+     * Filter an array, or a promise of an array, which contains a promises (or a mix of promises and values) with the given `filterer` function with the signature `(item, index, arrayLength)` where `item` is the resolved value of a respective promise in the input array. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * The return values from the filtered functions are coerced to booleans, with the exception of promises and thenables which are awaited for their eventual result.
+     *
+     * *The original array is not modified.
+     */
+    // promise of array with promises of value
+    filter<T>(values: PromiseLike<PromiseLike<T>[]>, filterer: (item: T, index: number, arrayLength: number) => boolean | PromiseLike<boolean>, option?: Promise.ConcurrencyOption): Promise<T[]>;
+
+    // promise of array with values
+    filter<T>(values: PromiseLike<T[]>, filterer: (item: T, index: number, arrayLength: number) => boolean | PromiseLike<boolean>, option?: Promise.ConcurrencyOption): Promise<T[]>;
+
+    // array with promises of value
+    filter<T>(values: PromiseLike<T>[], filterer: (item: T, index: number, arrayLength: number) => boolean | PromiseLike<boolean>, option?: Promise.ConcurrencyOption): Promise<T[]>;
+
+    // array with values
+    filter<T>(values: T[], filterer: (item: T, index: number, arrayLength: number) => boolean | PromiseLike<boolean>, option?: Promise.ConcurrencyOption): Promise<T[]>;
+
+    /**
+     * Iterate over an array, or a promise of an array, which contains promises (or a mix of promises and values) with the given iterator function with the signature (item, index, value) where item is the resolved value of a respective promise in the input array. Iteration happens serially. If any promise in the input array is rejected the returned promise is rejected as well.
+     *
+     * Resolves to the original array unmodified, this method is meant to be used for side effects. If the iterator function returns a promise or a thenable, the result for the promise is awaited for before continuing with next iteration.
+     */
+    // promise of array with promises of value
+    each<T, U>(values: PromiseLike<PromiseLike<T>[]>, iterator: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<T[]>;
+    // array with promises of value
+    each<T, U>(values: PromiseLike<T>[], iterator: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<T[]>;
+    // array with values OR promise of array with values
+    each<T, U>(values: T[] | PromiseLike<T[]>, iterator: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<T[]>;
+}
+
+interface Promise<T> extends PromiseLike<T>, Promise.Inspection<T> {
+    /**
+     * Promises/A+ `.then()` with progress handler. Returns a new promise chained from this promise. The new promise will be rejected or resolved dedefer on the passed `fulfilledHandler`, `rejectedHandler` and the state of this promise.
+     */
+    then<U>(onFulfill: (value: T) => U | PromiseLike<U>, onReject?: (error: any) => U | PromiseLike<U>, onProgress?: (note: any) => any): Promise<U>;
+    then<U>(onFulfill: (value: T) => U | PromiseLike<U>, onReject?: (error: any) => void | PromiseLike<void>, onProgress?: (note: any) => any): Promise<U>;
+
+    /**
+     * This is a catch-all exception handler, shortcut for calling `.then(null, handler)` on this promise. Any exception happening in a `.then`-chain will propagate to nearest `.catch` handler.
+     *
+     * Alias `.caught();` for compatibility with earlier ECMAScript version.
+     */
+    catch(onReject?: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+    caught(onReject?: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+
+    catch<U>(onReject?: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+    caught<U>(onReject?: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+
+    /**
+     * This extends `.catch` to work more like catch-clauses in languages like Java or C#. Instead of manually checking `instanceof` or `.name === "SomeError"`, you may specify a number of error constructors which are eligible for this catch handler. The catch handler that is first met that has eligible constructors specified, is the one that will be called.
+     *
+     * This method also supports predicate-based filters. If you pass a predicate function instead of an error constructor, the predicate will receive the error as an argument. The return result of the predicate will be used determine whether the error handler should be called.
+     *
+     * Alias `.caught();` for compatibility with earlier ECMAScript version.
+     */
+    catch(predicate: (error: any) => boolean, onReject: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+    caught(predicate: (error: any) => boolean, onReject: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+
+    catch<U>(predicate: (error: any) => boolean, onReject: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+    caught<U>(predicate: (error: any) => boolean, onReject: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+
+    catch(ErrorClass: Function, onReject: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+    caught(ErrorClass: Function, onReject: (error: any) => T | PromiseLike<T> | void | PromiseLike<void>): Promise<T>;
+
+    catch<U>(ErrorClass: Function, onReject: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+    caught<U>(ErrorClass: Function, onReject: (error: any) => U | PromiseLike<U>): Promise<U | T>;
+
+
+    /**
+     * Like `.catch` but instead of catching all types of exceptions, it only catches those that don't originate from thrown errors but rather from explicit rejections.
+     */
+    error<U>(onReject: (reason: any) => PromiseLike<U>): Promise<U>;
+    error<U>(onReject: (reason: any) => U): Promise<U>;
+
+    /**
+     * Pass a handler that will be called regardless of this promise's fate. Returns a new promise chained from this promise. There are special semantics for `.finally()` in that the final value cannot be modified from the handler.
+     *
+     * Alias `.lastly();` for compatibility with earlier ECMAScript version.
+     */
+    finally<U>(handler: () => U | PromiseLike<U>): Promise<T>;
+
+    lastly<U>(handler: () => U | PromiseLike<U>): Promise<T>;
+
+    /**
+     * Create a promise that follows this promise, but is bound to the given `thisArg` value. A bound promise will call its handlers with the bound value set to `this`. Additionally promises derived from a bound promise will also be bound promises with the same `thisArg` binding as the original promise.
+     */
+    bind(thisArg: any): Promise<T>;
+
+    /**
+     * Like `.then()`, but any unhandled rejection that ends up here will be thrown as an error.
+     */
+    done<U>(onFulfilled?: (value: T) => PromiseLike<U>, onRejected?: (error: any) => U | PromiseLike<U>, onProgress?: (note: any) => any): void;
+    done<U>(onFulfilled?: (value: T) => U, onRejected?: (error: any) => U | PromiseLike<U>, onProgress?: (note: any) => any): void;
+
+    /**
+     * Like `.finally()`, but not called for rejections.
+     */
+    tap<U>(onFulFill: (value: T) => U | PromiseLike<U>): Promise<T>;
+
+    /**
+     * Shorthand for `.then(null, null, handler);`. Attach a progress handler that will be called if this promise is progressed. Returns a new promise chained from this promise.
+     */
+    progressed(handler: (note: any) => any): Promise<T>;
+
+    /**
+     * Same as calling `Promise.delay(this, ms)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    delay(ms: number): Promise<T>;
+
+    /**
+     * Returns a promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within `ms` milliseconds, the returned promise is rejected with a `Promise.TimeoutError` instance.
+     *
+     * You may specify a custom error message with the `message` parameter.
+     */
+    timeout(ms: number, message?: string): Promise<T>;
+
+    /**
+     * Register a node-style callback on this promise. When this promise is is either fulfilled or rejected, the node callback will be called back with the node.js convention where error reason is the first argument and success value is the second argument. The error argument will be `null` in case of success.
+     * Returns back this promise instead of creating a new one. If the `callback` argument is not a function, this method does not do anything.
+     */
+    nodeify(callback: (err: any, value?: T) => void, options?: Promise.SpreadOption): Promise<T>;
+    nodeify(...sink: any[]): Promise<T>;
+
+    /**
+     * Marks this promise as cancellable. Promises by default are not cancellable after v0.11 and must be marked as such for `.cancel()` to have any effect. Marking a promise as cancellable is infectious and you don't need to remark any descendant promise.
+     */
+    cancellable(): Promise<T>;
+
+    /**
+     * Cancel this promise. The cancellation will propagate to farthest cancellable ancestor promise which is still pending.
+     *
+     * That ancestor will then be rejected with a `CancellationError` (get a reference from `Promise.CancellationError`) object as the rejection reason.
+     *
+     * In a promise rejection handler you may check for a cancellation by seeing if the reason object has `.name === "Cancel"`.
+     *
+     * Promises are by default not cancellable. Use `.cancellable()` to mark a promise as cancellable.
+     */
+    // TODO what to do with this?
+    cancel<U>(reason?: any): Promise<U>;
+
+    /**
+     * Like `.then()`, but cancellation of the the returned promise or any of its descendant will not propagate cancellation to this promise or this promise's ancestors.
+     */
+    fork<U>(onFulfilled?: (value: T) => U | PromiseLike<U>, onRejected?: (error: any) => U | PromiseLike<U>, onProgress?: (note: any) => any): Promise<U>;
+
+    /**
+     * Create an uncancellable promise based on this promise.
+     */
+    uncancellable(): Promise<T>;
+
+    /**
+     * See if this promise can be cancelled.
+     */
+    isCancellable(): boolean;
+
+    /**
+     * See if this `promise` has been fulfilled.
+     */
+    isFulfilled(): boolean;
+
+    /**
+     * See if this `promise` has been rejected.
+     */
+    isRejected(): boolean;
+
+    /**
+     * See if this `promise` is still defer.
+     */
+    isPending(): boolean;
+
+    /**
+     * See if this `promise` is resolved -> either fulfilled or rejected.
+     */
+    isResolved(): boolean;
+
+    /**
+     * Get the fulfillment value of the underlying promise. Throws if the promise isn't fulfilled yet.
+     *
+     * throws `TypeError`
+     */
+    value(): T;
+
+    /**
+     * Get the rejection reason for the underlying promise. Throws if the promise isn't rejected yet.
+     *
+     * throws `TypeError`
+     */
+    reason(): any;
+
+    /**
+     * Synchronously inspect the state of this `promise`. The `PromiseInspection` will represent the state of the promise as snapshotted at the time of calling `.inspect()`.
+     */
+    inspect(): Promise.Inspection<T>;
+
+    /**
+     * This is a convenience method for doing:
+     *
+     * <code>
+     * promise.then(function(obj){
+    *     return obj[propertyName].call(obj, arg...);
+    * });
+     * </code>
+     */
+    call(propertyName: string, ...args: any[]): Promise<any>;
+
+    /**
+     * This is a convenience method for doing:
+     *
+     * <code>
+     * promise.then(function(obj){
+    *     return obj[propertyName];
+    * });
+     * </code>
+     */
+    // TODO find way to fix get()
+    // get<U>(propertyName: string): Promise<U>;
+
+    /**
+     * Convenience method for:
+     *
+     * <code>
+     * .then(function() {
+    *    return value;
+    * });
+     * </code>
+     *
+     * in the case where `value` doesn't change its value. That means `value` is bound at the time of calling `.return()`
+     *
+     * Alias `.thenReturn();` for compatibility with earlier ECMAScript version.
+     */
+    return(): Promise<any>;
+    thenReturn(): Promise<any>;
+    return<U>(value: U): Promise<U>;
+    thenReturn<U>(value: U): Promise<U>;
+
+    /**
+     * Convenience method for:
+     *
+     * <code>
+     * .then(function() {
+    *    throw reason;
+    * });
+     * </code>
+     * Same limitations apply as with `.return()`.
+     *
+     * Alias `.thenThrow();` for compatibility with earlier ECMAScript version.
+     */
+    throw(reason: Error): Promise<T>;
+    thenThrow(reason: Error): Promise<T>;
+
+    /**
+     * Convert to String.
+     */
+    toString(): string;
+
+    /**
+     * This is implicitly called by `JSON.stringify` when serializing the object. Returns a serialized representation of the `Promise`.
+     */
+    toJSON(): Object;
+
+    /**
+     * Like calling `.then`, but the fulfillment value or rejection reason is assumed to be an array, which is flattened to the formal parameters of the handlers.
+     */
+    // TODO how to model instance.spread()? like Q?
+    spread<U>(onFulfill: Function, onReject?: (reason: any) => U | PromiseLike<U>): Promise<U>;
+    /*
+     // TODO or something like this?
+     spread<U, W>(onFulfill: (...values: W[]) => PromiseLike<U>, onReject?: (reason: any) => PromiseLike<U>): Promise<U>;
+     spread<U, W>(onFulfill: (...values: W[]) => PromiseLike<U>, onReject?: (reason: any) => U): Promise<U>;
+     spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => PromiseLike<U>): Promise<U>;
+     spread<U, W>(onFulfill: (...values: W[]) => U, onReject?: (reason: any) => U): Promise<U>;
+     */
+    /**
+     * Same as calling `Promise.all(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    all<U>(): Promise<U[]>;
+
+    /**
+     * Same as calling `Promise.props(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO how to model instance.props()?
+    props(): Promise<Object>;
+
+    /**
+     * Same as calling `Promise.settle(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    settle<U>(): Promise<Promise.Inspection<U>[]>;
+
+    /**
+     * Same as calling `Promise.any(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    any<U>(): Promise<U>;
+
+    /**
+     * Same as calling `Promise.some(thisPromise)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    some<U>(count: number): Promise<U[]>;
+
+    /**
+     * Same as calling `Promise.race(thisPromise, count)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    race<U>(): Promise<U>;
+
+    /**
+     * Same as calling `Promise.map(thisPromise, mapper)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    map<Q, U>(mapper: (item: Q, index: number, arrayLength: number) => U | PromiseLike<U>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    /**
+     * Same as `Promise.mapSeries(thisPromise, mapper)`.
+     */
+    // TODO type inference from array-resolving promise?
+    mapSeries<Q, U>(mapper: (item: Q, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<U[]>;
+
+    /**
+     * Same as calling `Promise.reduce(thisPromise, Function reducer, initialValue)`. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    reduce<Q, U>(reducer: (memo: U, item: Q, index: number, arrayLength: number) => U | PromiseLike<U>, initialValue?: U): Promise<U>;
+
+    /**
+     * Same as calling ``Promise.filter(thisPromise, filterer)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    // TODO type inference from array-resolving promise?
+    filter<U>(filterer: (item: U, index: number, arrayLength: number) => boolean | PromiseLike<boolean>, options?: Promise.ConcurrencyOption): Promise<U[]>;
+
+    /**
+     * Same as calling ``Promise.each(thisPromise, iterator)``. With the exception that if this promise is bound to a value, the returned promise is bound to that value too.
+     */
+    each<T, U>(iterator: (item: T, index: number, arrayLength: number) => U | PromiseLike<U>): Promise<T[]>;
+}
+
+/**
+ * Don't use variable namespace such as variables, functions, and classes.
+ * If you use this namespace, it will conflict in es6.
+ */
+declare namespace Promise {
+    export interface RangeError extends Error {
+    }
+    export interface CancellationError extends Error {
+    }
+    export interface TimeoutError extends Error {
+    }
+    export interface TypeError extends Error {
+    }
+    export interface RejectionError extends Error {
+    }
+    export interface OperationalError extends Error {
+    }
+
+    export interface ConcurrencyOption {
+        concurrency: number;
+    }
+    export interface SpreadOption {
+        spread: boolean;
+    }
+    export interface PromisifyAllOptions {
+        suffix?: string;
+        filter?: (name: string, func: Function, target?: any, passesDefaultFilter?: boolean) => boolean;
+        // The promisifier gets a reference to the original method and should return a function which returns a promise
+        promisifier?: (originalMethod: Function) => () => PromiseLike<any>;
+    }
+
+    export interface Resolver<T> {
+        /**
+         * Returns a reference to the controlled promise that can be passed to clients.
+         */
+        promise: Promise<T>;
+
+        /**
+         * Resolve the underlying promise with `value` as the resolution value. If `value` is a thenable or a promise, the underlying promise will assume its state.
+         */
+        resolve(value: T): void;
+        resolve(): void;
+
+        /**
+         * Reject the underlying promise with `reason` as the rejection reason.
+         */
+        reject(reason: any): void;
+
+        /**
+         * Progress the underlying promise with `value` as the progression value.
+         */
+        progress(value: any): void;
+
+        /**
+         * Gives you a callback representation of the `PromiseResolver`. Note that this is not a method but a property. The callback accepts error object in first argument and success values on the 2nd parameter and the rest, I.E. node js conventions.
+         *
+         * If the the callback is called with multiple success values, the resolver fullfills its promise with an array of the values.
+         */
+        // TODO specify resolver callback
+        callback: (err: any, value: T, ...values: T[]) => void;
+    }
+
+    export interface Inspection<T> {
+        /**
+         * See if the underlying promise was fulfilled at the creation time of this inspection object.
+         */
+        isFulfilled(): boolean;
+
+        /**
+         * See if the underlying promise was rejected at the creation time of this inspection object.
+         */
+        isRejected(): boolean;
+
+        /**
+         * See if the underlying promise was defer at the creation time of this inspection object.
+         */
+        isPending(): boolean;
+
+        /**
+         * Get the fulfillment value of the underlying promise. Throws if the promise wasn't fulfilled at the creation time of this inspection object.
+         *
+         * throws `TypeError`
+         */
+        value(): T;
+
+        /**
+         * Get the rejection reason for the underlying promise. Throws if the promise wasn't rejected at the creation time of this inspection object.
+         *
+         * throws `TypeError`
+         */
+        reason(): any;
+    }
+}
+
+declare module 'bluebird' {
+    export = Promise;
+}

bluebird/bluebird-tests.ts

@@ -7,6 +7,8 @@
 
 // Note: try to maintain the ordering and separators, and keep to the pattern
 
+import Promise = require("bluebird");
+
 var obj: Object;
 var bool: boolean;
 var num: number;
@@ -141,7 +143,7 @@ var fooResolver: Promise.Resolver<Foo>;
 var barResolver: Promise.Resolver<Bar>;
 
 var fooInspection: Promise.Inspection<Foo>;
-var barInspection: Promise.Inspection<Bar>;
+var fooInspectionPromise: Promise<Promise.Inspection<Foo>>;
 
 var fooInspectionArrProm: Promise<Promise.Inspection<Foo>[]>;
 var barInspectionArrProm: Promise<Promise.Inspection<Bar>[]>;
@@ -195,8 +197,6 @@ fooResolver.resolve(foo);
 
 fooResolver.reject(err);
 
-fooResolver.progress(bar);
-
 fooResolver.callback = (err: any, value: Foo) => {
 
 };
@@ -204,24 +204,13 @@ fooResolver.callback = (err: any, value: Foo) => {
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 bool = fooInspection.isFulfilled();
-
 bool = fooInspection.isRejected();
-
 bool = fooInspection.isPending();
-
 foo = fooInspection.value();
-
 x = fooInspection.reason();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-barProm = fooProm.then((value: Foo) => {
-	return bar;
-}, (reason: any) => {
-	return bar;
-}, (note: any) => {
-	return bar;
-});
 barProm = fooProm.then((value: Foo) => {
 	return bar;
 }, (reason: any) => {
@@ -384,13 +373,6 @@ fooProm = fooProm.bind(obj);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-voidVar = fooProm.done((value: Foo) => {
-	return bar;
-}, (reason: any) => {
-	return bar;
-}, (note: any) => {
-
-});
 voidVar = fooProm.done((value: Foo) => {
 	return bar;
 }, (reason: any) => {
@@ -402,13 +384,6 @@ voidVar = fooProm.done((value: Foo) => {
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-voidVar = fooProm.done((value: Foo) => {
-	return barThen;
-}, (reason: any) => {
-	return barThen;
-}, (note: any) => {
-
-});
 voidVar = fooProm.done((value: Foo) => {
 	return barThen;
 }, (reason: any) => {
@@ -436,11 +411,6 @@ fooProm = fooProm.tap(() => {
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = fooProm.progressed((note: any) => {
-	return foo;
-});
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
 fooProm = fooProm.delay(num);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -460,52 +430,11 @@ fooProm = fooProm.nodeify((err: any, foo?: Foo) => { }, { spread: true });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-barProm = fooProm.fork((value: Foo) => {
-	return bar;
-}, (reason: any) => {
-	return bar;
-}, (note: any) => {
-
-});
-barProm = fooProm.fork((value: Foo) => {
-	return bar;
-}, (reason: any) => {
-	return bar;
-});
-barProm = fooProm.fork((value: Foo) => {
-	return bar;
-});
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-barProm = fooProm.fork((value: Foo) => {
-	return barThen;
-}, (reason: any) => {
-	return barThen;
-}, (note: any) => {
-
-});
-barProm = fooProm.fork((value: Foo) => {
-	return barThen;
-}, (reason: any) => {
-	return barThen;
-});
-barProm = fooProm.fork((value: Foo) => {
-	return barThen;
-});
+voidVar = fooProm.cancel();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-barProm = fooProm.cancel<Bar>();
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-fooProm = fooProm.cancellable();
-fooProm = fooProm.uncancellable();
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-bool = fooProm.isCancellable();
+bool = fooProm.isCancelled();
 bool = fooProm.isFulfilled();
 bool = fooProm.isRejected();
 bool = fooProm.isPending();
@@ -513,8 +442,6 @@ bool = fooProm.isResolved();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooInspection = fooProm.inspect();
-
 anyProm = fooProm.call(str);
 anyProm = fooProm.call(str, 1, 2, 3);
 
@@ -543,22 +470,12 @@ obj = fooProm.toJSON();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
-	return bar;
-}, (reason: any) => {
-	return bar;
-});
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
 	return bar;
 });
 
 // - - - - - - - - - - - - - - - - -
 
-barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar) => {
-	return barThen;
-}, (reason: any) => {
-	return barThen;
-});
 barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
 	return barThen;
 });
@@ -568,15 +485,10 @@ barProm = fooArrProm.spread<Bar>((one: Foo, two: Bar, twotwo: Foo) => {
 //TODO fix collection inference
 
 barArrProm = fooProm.all<Bar>();
-
 objProm = fooProm.props();
-
-barInspectionArrProm = fooProm.settle<Bar>();
-
+fooInspectionPromise = fooProm.reflect();
 barProm = fooProm.any<Bar>();
-
 barArrProm = fooProm.some<Bar>(num);
-
 barProm = fooProm.race<Bar>();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -686,24 +598,12 @@ fooProm = Promise.try<Foo>(() => {
 fooProm = Promise.try(() => {
 	return foo;
 });
-fooProm = Promise.try(() => {
-	return foo;
-}, arr);
-fooProm = Promise.try(() => {
-	return foo;
-}, arr, x);
 
 // - - - - - - - - - - - - - - - - -
 
 fooProm = Promise.try(() => {
 	return fooThen;
 });
-fooProm = Promise.try(() => {
-	return fooThen;
-}, arr);
-fooProm = Promise.try(() => {
-	return fooThen;
-}, arr, x);
 
 // - - - - - - - - - - - - - - - - -
 
@@ -725,12 +625,6 @@ fooProm = Promise.attempt<Foo>(() => {
 fooProm = Promise.attempt(() => {
 	return foo;
 });
-fooProm = Promise.attempt(() => {
-	return foo;
-}, arr);
-fooProm = Promise.attempt(() => {
-	return foo;
-}, arr, x);
 
 // - - - - - - - - - - - - - - - - -
 
@@ -746,12 +640,6 @@ fooProm = Promise.attempt(() => {
 fooProm = Promise.attempt(() => {
 	return fooThen;
 });
-fooProm = Promise.attempt(() => {
-	return fooThen;
-}, arr);
-fooProm = Promise.attempt(() => {
-	return fooThen;
-}, arr, x);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -847,6 +735,7 @@ obj = Promise.promisifyAll(obj, {
  */
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+BlueBird = Promise.getNewLibraryCopy();
 BlueBird = Promise.noConflict();
 
 Promise.onPossiblyUnhandledRejection((reason: any) => {
@@ -868,14 +757,6 @@ objProm = Promise.props(obj);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-//TODO expand tests to overloads
-fooInspectionArrProm = Promise.settle(fooThenArrThen);
-fooInspectionArrProm = Promise.settle(fooArrProm);
-fooInspectionArrProm = Promise.settle(fooThenArr);
-fooInspectionArrProm = Promise.settle(fooArr);
-
-// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
 //TODO expand tests to overloads
 fooProm = Promise.any(fooThenArrThen);
 fooProm = Promise.any(fooArrProm);

bookshelf/bookshelf.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Andrew Schurman <http://github.com/arcticwaters>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path='../lodash/lodash-3.10.d.ts' />
 /// <reference path="../knex/knex.d.ts" />
 /// <reference path="../create-error/create-error.d.ts" />

bootstrap-datepicker/bootstrap-datepicker-tests.ts

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

bootstrap-datepicker/bootstrap-datepicker.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bootstrap.datepicker
+// Type definitions for bootstrap-datepicker
 // Project: https://github.com/eternicode/bootstrap-datepicker
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

chroma-js/chroma-js-tests.ts

@@ -1,5 +1,7 @@
 /// <reference path="chroma-js.d.ts" />
 
+import * as myChroma from "chroma-js";
+
 function test_chroma() {
     chroma('hotpink');
     chroma('#ff3399');
@@ -41,6 +43,9 @@ function test_chroma() {
     chroma.limits(data, 'e', 5);
     chroma.limits(data, 'q', 5);
     chroma.limits(data, 'k', 5);
+
+    myChroma(0xff3399);
+    myChroma.limits(data, 'k', 5);
 }
 
 function test_color() {
@@ -99,6 +104,10 @@ function test_color() {
     chroma('#cbdbff').temperature();
     chroma('#b3ccff').temperature();
     chroma('33cc00').gl();
+
+    myChroma('teal').alpha(0.5).css();
+    myChroma('teal').css('hsl');
+    myChroma('orange').rgb();
 }
 
 function test_scale() {
@@ -163,4 +172,17 @@ function test_scale() {
 
     chroma.scale('OrRd').classes(5);
     chroma.scale('OrRd').classes(8);
-}
+
+    myChroma.cubehelix()
+        .start(200)
+        .rotations(-0.35)
+        .gamma(0.7)
+        .lightness([0.3, 0.8])
+        .scale() // convert to chroma.scale
+
+        .correctLightness()
+        .colors(5);
+
+    myChroma.scale('RdYlBu');
+    myChroma.scale('RdYlBu').padding(0.15);
+}

chroma-js/chroma-js.d.ts

@@ -263,3 +263,7 @@ declare namespace Chroma {
 }
 
 declare var chroma: Chroma.ChromaStatic;
+
+declare module "chroma-js" {
+    export = chroma;
+}

consolidate/consolidate.d.ts

@@ -6,7 +6,7 @@
 // Imported from: https://github.com/soywiz/typescript-node-definitions/consolidate.d.ts
 
 /// <reference path="../node/node.d.ts" />
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 
 declare module "consolidate" {
 	var cons: Consolidate;

db-migrate-base/db-migrate-base-tests.ts

@@ -0,0 +1,322 @@
+// Test file for db-migrate-base Definition file
+/// <reference path="db-migrate-base.d.ts" />
+
+import * as DbMigrateBase from "db-migrate-base";
+
+// Throw together a dummy driver
+let db = <DbMigrateBase.Base>{};
+
+let callback = (err: any, response: any) => {
+  // Do nothing.
+};
+
+/// createTable(tableName, columnSpec, callback)
+db.createTable('pets', {
+  id: { type: 'int', primaryKey: true, autoIncrement: true },
+  name: 'string'
+}, callback);
+
+db.createTable('pets', {
+  columns: {
+    id: { type: 'int', primaryKey: true, autoIncrement: true },
+    name: 'string'
+  },
+  ifNotExists: true
+}, callback);
+
+db.createTable('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: 'id'
+    }
+  }
+}, callback);
+
+db.createTable('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: {
+        product_id: 'id'
+      }
+    }
+  }
+}, callback);
+
+/// dropTable(tableName, [options,] callback)
+db.dropTable('pets', callback);
+
+db.dropTable('pets', { ifExists: true }, callback);
+
+/// renameTable(tableName, newTableName, callback)
+db.renameTable('pets', 'pets_OLD', callback);
+
+/// addColumn(tableName, columnName, columnSpec, callback)
+db.addColumn('pets', 'eyeColor', {
+  type: 'string',
+  length: 25,
+  notNull: true,
+}, callback);
+
+db.addColumn('pets', 'id', {
+  type: 'int',
+  primaryKey: true,
+  autoIncrement: true,
+  notNull: true,
+  unique: true
+}, callback);
+
+/// renameColumn(tableName, oldColumnName, newColumnName, callback)
+db.renameColumn('pets', 'id', 'pet_id', callback);
+
+/// changeColumn(tableName, columnName, columnSpec, callback)
+db.changeColumn('pets', 'eye_color', {
+  type: 'int',
+  unsigned: true,
+  notNull: true,
+  foreignKey: {
+    name: 'pets_eye_color_id_fk',
+    table: 'eye_color',
+    rules: {
+      onDelete: 'CASCADE',
+      onUpdate: 'RESTRICT'
+    },
+    mapping: {
+      eye_color: 'id'
+    }
+  }
+}, callback);
+
+/// addIndex(tableName, indexName, columns, [unique,] callback)
+db.addIndex('pets', 'pets_eye_color_idx', ['eye_color'], callback);
+db.addIndex('pets', 'pets_registration_code_idx', ['registration_code'], true, callback);
+
+/// addForeignKey(tableName, referencedTableName, keyName, fieldMapping, rules, callback)
+db.addForeignKey('module_user', 'modules', 'module_user_module_id_fk',
+{
+  'module_id': 'id'
+},
+{
+  onDelete: 'CASCADE',
+  onUpdate: 'RESTRICT'
+}, callback);
+
+/// removeForeignKey(tableName, keyName, options, callback)
+db.removeForeignKey('module_user', 'module_uer_module_id_foreign', callback);
+db.removeForeignKey('module_user', 'module_user_module_id_foreign', {
+  dropIndex: true,
+}, callback);
+
+/// insert(tableName, [columnNameArray,] valueArray, callback)
+db.insert('module_user', ['first_name', 'last_name'], ['Test', 'Testerson'], callback);
+db.insert('module_user', ['Test', 'Testerson'], callback);
+
+/// removeIndex([tableName,] indexName, callback)
+db.removeIndex('pets', 'pets_eye_color_idx', callback);
+db.removeIndex('pets_eye_color_idx', callback);
+
+/// runSql(sql, [params,] callback)
+db.runSql('INSERT INTO `module_user` (`?`,`?`) VALUES (\'?\',\'?\')', [
+  'first_name', 'last_name',
+  'Test', 'Testerson'
+], callback);
+db.runSql('DROP TABLE `pets`', callback);
+
+/// all(sql, [params,] callback)
+db.all('SELECT * FROM `module_user` WHERE `?` = \'?\'', ['first_name', 'Test'], callback);
+db.all('SELECT * FROM `module_user`', callback);
+
+/// =========
+///   Async
+/// =========
+
+let onResolve = (result: any) => {};
+
+/// createTableAsync(tableName, columnSpec)
+db.createTableAsync('pets', {
+  id: { type: 'int', primaryKey: true, autoIncrement: true },
+  name: 'string'
+}).then(onResolve);
+
+db.createTableAsync('pets', {
+  columns: {
+    id: { type: 'int', primaryKey: true, autoIncrement: true },
+    name: 'string'
+  },
+  ifNotExists: true
+}).then(onResolve);
+
+db.createTableAsync('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: 'id'
+    }
+  }
+}).then(onResolve);
+
+db.createTableAsync('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: {
+        product_id: 'id'
+      }
+    }
+  }
+}).then(onResolve);
+
+/// dropTableAsync(tableName, [options])
+db.dropTableAsync('pets').then(onResolve);
+db.dropTableAsync('pets', { ifExists: true }).then(onResolve);
+
+/// renameTableAsync(tableName, newTableName)
+db.renameTableAsync('pets', 'pets_OLD').then(onResolve);
+
+/// addColumnAsync(tableName, columnName, columnSpec)
+db.addColumnAsync('pets', 'eyeColor', {
+  type: 'string',
+  length: 25,
+  notNull: true,
+}).then(onResolve);
+
+db.addColumnAsync('pets', 'id', {
+  type: 'int',
+  primaryKey: true,
+  autoIncrement: true,
+  notNull: true,
+  unique: true
+}).then(onResolve);
+
+/// renameColumnAsync(tableName, oldColumnName, newColumnName)
+db.renameColumnAsync('pets', 'id', 'pet_id').then(onResolve);
+
+/// changeColumnAsync(tableName, columnName, columnSpec)
+db.changeColumnAsync('pets', 'eye_color', {
+  type: 'int',
+  unsigned: true,
+  notNull: true,
+  foreignKey: {
+    name: 'pets_eye_color_id_fk',
+    table: 'eye_color',
+    rules: {
+      onDelete: 'CASCADE',
+      onUpdate: 'RESTRICT'
+    },
+    mapping: {
+      eye_color: 'id'
+    }
+  }
+}).then(onResolve);
+
+/// addIndexAsync(tableName, indexName, columns, [unique])
+db.addIndexAsync('pets', 'pets_eye_color_idx', ['eye_color']).then(onResolve);
+db.addIndexAsync('pets', 'pets_registration_code_idx', ['registration_code'], true).then(onResolve);
+
+/// addForeignKeyAsync(tableName, referencedTableName, keyName, fieldMapping, rules)
+db.addForeignKeyAsync('module_user', 'modules', 'module_user_module_id_fk',
+{
+  'module_id': 'id'
+},
+{
+  onDelete: 'CASCADE',
+  onUpdate: 'RESTRICT'
+}).then(onResolve);
+
+/// removeForeignKeyAsync(tableName, keyName, options)
+db.removeForeignKeyAsync('module_user', 'module_uer_module_id_foreign').then(onResolve);
+db.removeForeignKeyAsync('module_user', 'module_user_module_id_foreign', {
+  dropIndex: true,
+}).then(onResolve);
+
+/// insertAsync(tableName, [columnNameArray,] valueArray)
+db.insertAsync('module_user', ['first_name', 'last_name'], ['Test', 'Testerson']).then(onResolve);
+db.insertAsync('module_user', ['Test', 'Testerson']).then(onResolve);
+
+/// removeIndexAsync([tableName,] indexName)
+db.removeIndexAsync('pets', 'pets_eye_color_idx').then(onResolve);
+db.removeIndexAsync('pets_eye_color_idx').then(onResolve);
+
+/// runSqlAsync(sql, [params])
+db.runSqlAsync('INSERT INTO `module_user` (`?`,`?`) VALUES (\'?\',\'?\')', [
+  'first_name', 'last_name',
+  'Test', 'Testerson'
+]).then(onResolve);
+db.runSqlAsync('DROP TABLE `pets`').then(onResolve);
+
+/// allAsync(sql, [params])
+db.allAsync('SELECT * FROM `module_user` WHERE `?` = \'?\'', ['first_name', 'Test']).then(onResolve);
+db.allAsync('SELECT * FROM `module_user`').then(onResolve);

db-migrate-base/db-migrate-base.d.ts

@@ -0,0 +1,152 @@
+// Type definitions for db-migrate-base
+// Project: https://github.com/db-migrate/db-migrate-base
+// Definitions by: nickiannone <https://github.com/nickiannone>
+// Definitions: https://github.com/nickiannone/DefinitelyTyped
+
+/// <reference path="../bluebird/bluebird.d.ts"/>
+/// <reference path="../node/node.d.ts"/>
+
+declare module "db-migrate-base" {
+
+  import * as Promise from "bluebird";
+
+  export interface CallbackFunction { (err: any, response: any): void; }
+
+  export interface InternalModule {
+    log: any;
+    type: any;
+  }
+
+  export interface InternalOptions {
+    mod: InternalModule;
+  }
+
+  export interface ColumnSpec {
+    length?: number;
+    type: string;
+    unsigned?: boolean;
+    primaryKey?: boolean;
+    autoIncrement?: boolean;
+    notNull?: boolean;
+    unique?: boolean;
+    defaultValue?: any;
+    foreignKey?: ForeignKeySpec;
+  }
+
+  export interface ForeignKeySpec {
+    name: string;
+    table: string;
+    rules?: ForeignKeyRules;
+    mapping: string | any;
+  }
+
+  export interface ForeignKeyRules {
+    onDelete: string;
+    onUpdate: string;
+  }
+
+  export interface RemoveForeignKeyOptions {
+    dropIndex?: boolean;
+  }
+
+  export interface ColumnDef {
+    foreignKey?: any; // TODO Figure this out!
+    constraints: string;
+  }
+
+  export interface CreateTableOptions {
+    columns?: Array<ColumnSpec>;
+    ifNotExists?: boolean;
+  }
+
+  export interface DropTableOptions {
+    ifExists?: boolean;
+  }
+
+  export class Base {
+    constructor(intern: InternalOptions);
+
+    close(callback?: CallbackFunction): void;
+    mapDataType(str: string): string;
+    truncate(tableName: string, callback: CallbackFunction): void;
+    checkDBMS(dbms: any, callback: CallbackFunction): void;
+    createDatabase(...options: any[]): void;
+    switchDatabase(...options: any[]): void;
+    dropDatabase(...options: any[]): void;
+    recurseCallbackArray(foreignKeys: Array<string>, callback: CallbackFunction): void;
+    bindForeignKey(tableName: string, columnName: string, fkOptions: ForeignKeySpec): (callback: CallbackFunction) => void;
+    createColumnDef(name: string, spec: ColumnSpec, options?: any): ColumnDef;  // TODO Figure out a type for `options`!
+    //createColumnConstraint(spec: ColumnSpec, options?: any, ...implementationDefinedOptions: any[]): string;
+    createMigrationsTable(callback: CallbackFunction): void;
+    createSeedsTable(callback: CallbackFunction): void;
+    createTable(tableName: string, options: any | CreateTableOptions, callback: CallbackFunction): void;
+    dropTable(tableName: string, optionsOrCb?: DropTableOptions | CallbackFunction, callback?: CallbackFunction): void;
+    renameTable(tableName: string, newTableName: string, callback: CallbackFunction): void;
+    addColumn(tableName: string, columnName: string, columnSpec: ColumnSpec, callback: CallbackFunction): void;
+    removeColumn(tableName: string, columnName: string, callback: CallbackFunction): void;
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string, callback: CallbackFunction): void;
+    changeColumn(tableName: string, columnName: string, columnSpec: ColumnSpec, callback: CallbackFunction): void;
+    quoteDDLArr(arr: Array<string>): Array<string>;
+    quoteArr(arr: Array<string>): Array<string>;
+    addIndex(tableName: string, indexName: string, columns: string | Array<string>, uniqueOrCb?: boolean | CallbackFunction, callback?: CallbackFunction): void;
+    insert(tableName: string, columnNameOrValueArray: any, valueArrayOrCb?: any | CallbackFunction, callback?: CallbackFunction): void;
+    update(tableName: string, columnNameOrValueArray: any, valueArrayOrIds?: any, idsOrCb?: any | CallbackFunction, callback?: CallbackFunction): void;
+    lookup(tableName: string, column: string, id?: any, callback?: CallbackFunction): void;
+    removeIndex(tableNameOrIndexName: string, indexNameOrCb?: string | CallbackFunction, callback?: CallbackFunction): void;
+    addForeignKey(tableName: string, referencedTableName: string, keyName: string, fieldMapping: any, rules: ForeignKeyRules, callback: CallbackFunction): void;
+    removeForeignKey(tableName: string, keyName: string, optionsOrCb?: RemoveForeignKeyOptions | CallbackFunction, callback?: CallbackFunction): void;
+    normalizeColumnSpec(spec: string | ColumnSpec): ColumnSpec;
+    addMigrationRecord(name: string, callback: CallbackFunction): void;
+    addSeedRecord(name: string, callback: CallbackFunction): void;
+    startMigration(callback: CallbackFunction): void;
+    endMigration(callback: CallbackFunction): void;
+    runSql(sql?: string, paramsOrCb?: Array<any> | CallbackFunction, callback?: CallbackFunction): void;
+    allLoadedMigrations(callback: CallbackFunction): void;
+    allLoadedSeeds(callback: CallbackFunction): void;
+    deleteMigration(migrationName: string, callback: CallbackFunction): void;
+    remove(table: string, ids: any, callback: CallbackFunction): void;  // TODO Make ids match the type of ids in buildWhereClause(ids);
+    buildWhereClause(ids: any): string;
+    deleteSeed(seedName: string, callback: CallbackFunction): void;
+    all(sql: string, paramsOrCb?: Array<any> | CallbackFunction, callback?: CallbackFunction): void;
+    escape(str: string): string;
+    escapeString(str: string): string;
+    escapeDDL(str: string): string;
+
+    // Promisified methods
+    closeAsync(): Promise<any>;
+    truncateAsync(tableName: string): Promise<any>;
+    checkDBMSAsync(dbms: any): Promise<any>;
+    createDatabaseAsync(...options: any[]): Promise<any>;
+    switchDatabaseAsync(...options: any[]): Promise<any>;
+    dropDatabaseAsync(...options: any[]): Promise<any>;
+    recurseCallbackArrayAsync(foreignKeys: Array<string>): Promise<any>;
+    createMigrationsTableAsync(): Promise<any>;
+    createSeedsTableAsync(): Promise<any>;
+    createTableAsync(tableName: string, options: any | CreateTableOptions): Promise<any>;
+    dropTableAsync(tableName: string, options?: DropTableOptions): Promise<any>;
+    renameTableAsync(tableName: string, newTableName: string): Promise<any>;
+    addColumnAsync(tableName: string, columnName: string, columnSpec: ColumnSpec): Promise<any>;
+    removeColumnAsync(tableName: string, columnName: string): Promise<any>;
+    renameColumnAsync(tableName: string, oldColumnName: string, newColumnName: string): Promise<any>;
+    changeColumnAsync(tableName: string, columnName: string, columnSpec: ColumnSpec): Promise<any>;
+    addIndexAsync(tableName: string, indexName: string, columns: string | Array<string>, unique?: boolean): Promise<any>;
+    insertAsync(tableName: string, columnNameOrValueArray: any, valueArrayOrCb?: any | CallbackFunction, callback?: CallbackFunction): Promise<any>;
+    updateAsync(tableName: string, columnNameOrValueArray: any, valueArrayOrIds?: any, idsOrCb?: any | CallbackFunction, callback?: CallbackFunction): Promise<any>;
+    lookupAsync(tableName: string, column: string, id?: any, callback?: CallbackFunction): Promise<any>;
+    removeIndexAsync(tableNameOrIndexName: string, indexName?: string): Promise<any>;
+    addForeignKeyAsync(tableName: string, referencedTableName: string, keyName: string, fieldMapping: any, rules: ForeignKeyRules): Promise<any>;
+    removeForeignKeyAsync(tableName: string, keyName: string, options?: RemoveForeignKeyOptions): Promise<any>;
+    addMigrationRecordAsync(name: string): Promise<any>;
+    addSeedRecordAsync(name: string): Promise<any>;
+    startMigrationAsync(): Promise<any>;
+    endMigrationAsync(callback: CallbackFunction): Promise<any>;
+    runSqlAsync(sql?: string, params?: Array<any>): Promise<any>;
+    allLoadedMigrationsAsync(): Promise<any>;
+    allLoadedSeedsAsync(): Promise<any>;
+    deleteMigrationAsync(migrationName: string): Promise<any>;
+    removeAsync(table: string, ids: any): Promise<any>;
+    deleteSeedAsync(seedName: string): Promise<any>;
+    allAsync(sql: string, params?: Array<any>): Promise<any>;
+  }
+
+}

db-migrate-pg/db-migrate-pg-tests.ts

@@ -0,0 +1,411 @@
+// Test file for db-migrate-pg Definition file
+/// <reference path="db-migrate-pg.d.ts" />
+
+import * as DbMigratePg from "db-migrate-pg";
+
+// Throw together a dummy driver
+let db = <DbMigratePg.PgDriver>{};
+
+let callback = (err: any, response: any) => {
+  // Do nothing.
+};
+
+/// createTable(tableName, columnSpec, callback)
+db.createTable('pets', {
+  id: { type: 'int', primaryKey: true, autoIncrement: true },
+  name: 'string'
+}, callback);
+
+db.createTable('pets', {
+  columns: {
+    id: { type: 'int', primaryKey: true, autoIncrement: true },
+    name: 'string'
+  },
+  ifNotExists: true
+}, callback);
+
+db.createTable('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: 'id'
+    }
+  }
+}, callback);
+
+db.createTable('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: {
+        product_id: 'id'
+      }
+    }
+  }
+}, callback);
+
+/// dropTable(tableName, [options,] callback)
+db.dropTable('pets', callback);
+
+db.dropTable('pets', { ifExists: true }, callback);
+
+/// renameTable(tableName, newTableName, callback)
+db.renameTable('pets', 'pets_OLD', callback);
+
+/// addColumn(tableName, columnName, columnSpec, callback)
+db.addColumn('pets', 'eyeColor', {
+  type: 'string',
+  length: 25,
+  notNull: true,
+}, callback);
+
+db.addColumn('pets', 'id', {
+  type: 'int',
+  primaryKey: true,
+  autoIncrement: true,
+  notNull: true,
+  unique: true
+}, callback);
+
+/// renameColumn(tableName, oldColumnName, newColumnName, callback)
+db.renameColumn('pets', 'id', 'pet_id', callback);
+
+/// changeColumn(tableName, columnName, columnSpec, callback)
+db.changeColumn('pets', 'eye_color', {
+  type: 'int',
+  unsigned: true,
+  notNull: true,
+  foreignKey: {
+    name: 'pets_eye_color_id_fk',
+    table: 'eye_color',
+    rules: {
+      onDelete: 'CASCADE',
+      onUpdate: 'RESTRICT'
+    },
+    mapping: {
+      eye_color: 'id'
+    }
+  }
+}, callback);
+
+/// addIndex(tableName, indexName, columns, [unique,] callback)
+db.addIndex('pets', 'pets_eye_color_idx', ['eye_color'], callback);
+db.addIndex('pets', 'pets_registration_code_idx', ['registration_code'], true, callback);
+
+/// addForeignKey(tableName, referencedTableName, keyName, fieldMapping, rules, callback)
+db.addForeignKey('module_user', 'modules', 'module_user_module_id_fk',
+{
+  'module_id': 'id'
+},
+{
+  onDelete: 'CASCADE',
+  onUpdate: 'RESTRICT'
+}, callback);
+
+/// removeForeignKey(tableName, keyName, options, callback)
+db.removeForeignKey('module_user', 'module_uer_module_id_foreign', callback);
+db.removeForeignKey('module_user', 'module_user_module_id_foreign', {
+  dropIndex: true,
+}, callback);
+
+/// insert(tableName, [columnNameArray,] valueArray, callback)
+db.insert('module_user', ['first_name', 'last_name'], ['Test', 'Testerson'], callback);
+db.insert('module_user', ['Test', 'Testerson'], callback);
+
+/// removeIndex([tableName,] indexName, callback)
+db.removeIndex('pets', 'pets_eye_color_idx', callback);
+db.removeIndex('pets_eye_color_idx', callback);
+
+/// runSql(sql, [params,] callback)
+db.runSql('INSERT INTO `module_user` (`?`,`?`) VALUES (\'?\',\'?\')', [
+  'first_name', 'last_name',
+  'Test', 'Testerson'
+], callback);
+db.runSql('DROP TABLE `pets`', callback);
+
+/// all(sql, [params,] callback)
+db.all('SELECT * FROM `module_user` WHERE `?` = \'?\'', ['first_name', 'Test'], callback);
+db.all('SELECT * FROM `module_user`', callback);
+
+/// =========
+///   Async
+/// =========
+
+let onResolve = (result: any) => {};
+
+/// createTableAsync(tableName, columnSpec)
+db.createTableAsync('pets', {
+  id: { type: 'int', primaryKey: true, autoIncrement: true },
+  name: 'string'
+}).then(onResolve);
+
+db.createTableAsync('pets', {
+  columns: {
+    id: { type: 'int', primaryKey: true, autoIncrement: true },
+    name: 'string'
+  },
+  ifNotExists: true
+}).then(onResolve);
+
+db.createTableAsync('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: 'id'
+    }
+  }
+}).then(onResolve);
+
+db.createTableAsync('product_variant', 
+{
+  id: {
+    type: 'int',
+    unsigned: true,
+    notNull: true,
+    primaryKey: true,
+    autoIncrement: true,
+    length: 10
+  },
+  product_id: {
+    type: 'int',
+    unsigned: true,
+    length: 10,
+    notNull: true,
+    foreignKey: {
+      name: 'product_variant_product_id_fk',
+      table: 'product',
+      rules: {
+        onDelete: 'CASCADE',
+        onUpdate: 'RESTRICT'
+      },
+      mapping: {
+        product_id: 'id'
+      }
+    }
+  }
+}).then(onResolve);
+
+/// dropTableAsync(tableName, [options])
+db.dropTableAsync('pets').then(onResolve);
+db.dropTableAsync('pets', { ifExists: true }).then(onResolve);
+
+/// renameTableAsync(tableName, newTableName)
+db.renameTableAsync('pets', 'pets_OLD').then(onResolve);
+
+/// addColumnAsync(tableName, columnName, columnSpec)
+db.addColumnAsync('pets', 'eyeColor', {
+  type: 'string',
+  length: 25,
+  notNull: true,
+}).then(onResolve);
+
+db.addColumnAsync('pets', 'id', {
+  type: 'int',
+  primaryKey: true,
+  autoIncrement: true,
+  notNull: true,
+  unique: true
+}).then(onResolve);
+
+/// renameColumnAsync(tableName, oldColumnName, newColumnName)
+db.renameColumnAsync('pets', 'id', 'pet_id').then(onResolve);
+
+/// changeColumnAsync(tableName, columnName, columnSpec)
+db.changeColumnAsync('pets', 'eye_color', {
+  type: 'int',
+  unsigned: true,
+  notNull: true,
+  foreignKey: {
+    name: 'pets_eye_color_id_fk',
+    table: 'eye_color',
+    rules: {
+      onDelete: 'CASCADE',
+      onUpdate: 'RESTRICT'
+    },
+    mapping: {
+      eye_color: 'id'
+    }
+  }
+}).then(onResolve);
+
+/// addIndexAsync(tableName, indexName, columns, [unique])
+db.addIndexAsync('pets', 'pets_eye_color_idx', ['eye_color']).then(onResolve);
+db.addIndexAsync('pets', 'pets_registration_code_idx', ['registration_code'], true).then(onResolve);
+
+/// addForeignKeyAsync(tableName, referencedTableName, keyName, fieldMapping, rules)
+db.addForeignKeyAsync('module_user', 'modules', 'module_user_module_id_fk',
+{
+  'module_id': 'id'
+},
+{
+  onDelete: 'CASCADE',
+  onUpdate: 'RESTRICT'
+}).then(onResolve);
+
+/// removeForeignKeyAsync(tableName, keyName, options)
+db.removeForeignKeyAsync('module_user', 'module_uer_module_id_foreign').then(onResolve);
+db.removeForeignKeyAsync('module_user', 'module_user_module_id_foreign', {
+  dropIndex: true,
+}).then(onResolve);
+
+/// insertAsync(tableName, [columnNameArray,] valueArray)
+db.insertAsync('module_user', ['first_name', 'last_name'], ['Test', 'Testerson']).then(onResolve);
+db.insertAsync('module_user', ['Test', 'Testerson']).then(onResolve);
+
+/// removeIndexAsync([tableName,] indexName)
+db.removeIndexAsync('pets', 'pets_eye_color_idx').then(onResolve);
+db.removeIndexAsync('pets_eye_color_idx').then(onResolve);
+
+/// runSqlAsync(sql, [params])
+db.runSqlAsync('INSERT INTO `module_user` (`?`,`?`) VALUES (\'?\',\'?\')', [
+  'first_name', 'last_name',
+  'Test', 'Testerson'
+]).then(onResolve);
+db.runSqlAsync('DROP TABLE `pets`').then(onResolve);
+
+/// allAsync(sql, [params])
+db.allAsync('SELECT * FROM `module_user` WHERE `?` = \'?\'', ['first_name', 'Test']).then(onResolve);
+db.allAsync('SELECT * FROM `module_user`').then(onResolve);
+
+/// ====================
+/// PG-specific tests
+/// ====================
+
+/// createColumnConstraint(spec, options, tableName, columnName) (INTERNAL USE ONLY)
+let constraint: DbMigratePg.ColumnConstraint;
+
+constraint = db.createColumnConstraint({
+  type: 'int',
+  length: 10,
+  unsigned: true,
+  primaryKey: false,
+  autoIncrement: false,
+  notNull: true,
+  unique: false,
+  defaultValue: 0,
+  foreignKey: {
+    name: 'pets_eye_color_id_fk',
+    table: 'eye_color',
+    rules: {
+      onDelete: 'CASCADE',
+      onUpdate: 'RESTRICT'
+    },
+    mapping: {
+      'eye_color': 'id'
+    }
+  }
+}, {
+  emitPrimaryKey: false
+}, 'pets', 'eye_color');
+
+// Print the SQL constraints
+console.log(constraint.constraints);
+
+// Invoke the foreign key builder
+constraint.foreignKey(callback);
+
+/// Public Callback Methods:
+
+/// createDatabase(dbName, [options,] callback)
+db.createDatabase('petstore', callback);
+db.createDatabase('petstore', {}, callback);
+
+/// dropDatabase(dbName, [options,] callback)
+db.dropDatabase('petstore', callback);
+db.dropDatabase('petstore', { ifExists: true }, callback);
+
+/// createSequence(sqName, [options,] callback)
+db.createSequence('pets_id_sq', callback);
+db.createSequence('pets_id_sq', { temp: true }, callback);
+
+/// switchDatabase(options, callback)
+db.switchDatabase('petstore', callback);
+db.switchDatabase({ database: 'petstore' }, callback);
+
+/// dropSequence(sqName, [options,] callback)
+db.dropSequence('pets_id_sq', callback);
+db.dropSequence('pets_id_sq', {
+  ifExists: true,
+  cascade: true,
+  restrict: true,
+}, callback);
+
+/// Public Promisified Methods:
+
+/// createDatabaseAsync(dbName, [options])
+db.createDatabaseAsync('petstore').then(onResolve);
+db.createDatabaseAsync('petstore', {}).then(onResolve);
+
+/// dropDatabaseAsync(dbName, [options])
+db.dropDatabaseAsync('petstore').then(onResolve);
+db.dropDatabaseAsync('petstore', { ifExists: true }).then(onResolve);
+
+/// createSequenceAsync(sqName, [options])
+db.createSequenceAsync('pets_id_sq').then(onResolve);
+db.createSequenceAsync('pets_id_sq', { temp: true }).then(onResolve);
+
+/// switchDatabaseAsync(options)
+db.switchDatabaseAsync('petstore').then(onResolve);
+db.switchDatabaseAsync({ database: 'petstore' }).then(onResolve);
+
+/// dropSequenceAsync(sqName, [options])
+db.dropSequenceAsync('pets_id_sq').then(onResolve);
+db.dropSequenceAsync('pets_id_sq', {
+  ifExists: true,
+  cascade: true,
+  restrict: true,
+}).then(onResolve);

db-migrate-pg/db-migrate-pg.d.ts

@@ -0,0 +1,60 @@
+// Type definitions for db-migrate-pg
+// Project: https://github.com/db-migrate/pg
+// Definitions by: nickiannone <http://github.com/nickiannone>
+// Definitions: https://github.com/nickiannone/DefinitelyTyped
+
+/// <reference path="../db-migrate-base/db-migrate-base.d.ts"/>
+/// <reference path="../pg/pg.d.ts" />
+
+declare module "db-migrate-pg" {
+
+  import * as pg from "pg";
+  import * as DbMigrateBase from "db-migrate-base";
+  import * as Promise from "bluebird";
+
+  // Yes, this is a dummy interface for now; the current implementation of the pg driver doesn't need any options.
+  export interface CreateDatabaseOptions {}
+
+  export interface DropDatabaseOptions {
+    ifExists?: boolean;
+  }
+
+  export interface CreateSequenceOptions {
+    temp?: boolean;
+  }
+
+  export interface SwitchDatabaseOptions {
+    database?: string;
+  }
+
+  export interface DropSequenceOptions {
+    ifExists?: boolean;
+    cascade?: boolean;
+    restrict?: boolean;
+  }
+
+  export interface ColumnConstraint {
+    foreignKey: (callback: DbMigrateBase.CallbackFunction) => void;
+    constraints: string;
+  }
+  
+  export interface ColumnConstraintOptions {
+    emitPrimaryKey?: boolean;
+  }
+
+  export class PgDriver extends DbMigrateBase.Base {
+    constructor(connection: pg.Client, schema: string, intern: DbMigrateBase.InternalOptions);
+    createDatabase(dbName: string, optionsOrCb: CreateDatabaseOptions | DbMigrateBase.CallbackFunction, callback?: DbMigrateBase.CallbackFunction): void;
+    dropDatabase(dbName: string, optionsOrCb: DropDatabaseOptions | DbMigrateBase.CallbackFunction, callback?: DbMigrateBase.CallbackFunction): void;
+    createSequence(sqName: string, optionsOrCb: CreateSequenceOptions | DbMigrateBase.CallbackFunction, callback?: DbMigrateBase.CallbackFunction): void;
+    switchDatabase(options: string | SwitchDatabaseOptions, callback: DbMigrateBase.CallbackFunction): void;
+    dropSequence(dbName: string, optionsOrCb: DropSequenceOptions | DbMigrateBase.CallbackFunction, callback?: DbMigrateBase.CallbackFunction): void;
+    createColumnConstraint(spec: DbMigrateBase.ColumnSpec, options: ColumnConstraintOptions, tableName: string, columnName: string): ColumnConstraint;
+
+    createDatabaseAsync(dbName: string, options?: CreateDatabaseOptions): Promise<any>;
+    dropDatabaseAsync(dbName: string, options?: DropDatabaseOptions): Promise<any>;
+    createSequenceAsync(sqName: string, options?: CreateSequenceOptions): Promise<any>;
+    switchDatabaseAsync(options: string | SwitchDatabaseOptions): Promise<any>;
+    dropSequenceAsync(dbName: string, options?: DropSequenceOptions): Promise<any>;
+  }
+}

devtools-detect/devtools-detect-tests.ts

@@ -0,0 +1,12 @@
+/// <reference path="devtools-detect.d.ts" />
+
+// check if it's open
+console.log('is DevTools open?', window.devtools.open);
+// check it's orientation, null if not open
+console.log('and DevTools orientation?', window.devtools.orientation);
+
+// get notified when it's opened/closed or orientation changes
+window.addEventListener('devtoolschange', function (e) {
+    console.log('is DevTools open?', e.detail.open);
+    console.log('and DevTools orientation?', e.detail.orientation);
+});

devtools-detect/devtools-detect.d.ts

@@ -0,0 +1,16 @@
+// Type definitions for ajv
+// Project: https://github.com/sindresorhus/devtools-detect
+// Definitions by: York Yao <https://github.com/plantain-00/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+type DevTools = {
+    open: boolean;
+    orientation: "vertical" | "horizontal";
+}
+interface DevToolsEvent extends Event {
+    detail: DevTools;
+}
+interface Window {
+    devtools: DevTools;
+    addEventListener(type: "devtoolschange", listener: (ev: DevToolsEvent) => any, useCapture?: boolean): void;
+}

documentdb/documentdb.d.ts

@@ -93,8 +93,13 @@ declare module 'documentdb' {
 
     /** Represents the result returned from a query. */
     interface QueryIterator<TResultRow> {
-
-        toArray(callback: (error: QueryError, result: TResultRow[]) => void): void;
+        current(): TResultRow;
+        executeNext(callback: (error: QueryError, result: TResultRow[], responseHeaders? : any) => void): void;
+        forEach(iteratorFunction : (error: QueryError, element: TResultRow, responseHeaders? : any) => void): void;
+        hasMoreResults(): boolean;
+        nextItem(callback: (error : QueryError, item : TResultRow, responseHeaders? : any) => void): void;
+        reset() : void;
+        toArray(callback: (error: QueryError, result: TResultRow[], responseHeaders? : any) => void): void;
     }
 
     /** Reprents an object with a unique identifier. */

domurl/domurl-tests.ts

@@ -0,0 +1,81 @@
+/// <reference path="domurl.d.ts" />
+
+interface UModel extends QueryString {
+    a: any;
+    b: string;
+}
+
+interface U2Model extends QueryString {
+    a: any;
+}
+
+interface U3Model extends QueryString {
+    foo: string;
+}
+
+var u = new Url<UModel>(); // current document URL will be used
+// or we can instantiate as
+var u2 = new Url<U2Model>("http://example.com/some/path?a=b&c=d#someAnchor");
+// it should support relative URLs also
+var u3 = new Url<U3Model>("/my/site/doc/path?foo=bar#baz");
+
+// get the value of some query string parameter
+console.log(u2.query.a);
+// or
+console.log(u3.query["foo"]);
+
+// Manipulating query string parameters
+u.query.a = [1, 2, 3]; // adds/replaces in query string params a=1&a=2&a=3
+u.query.b = 'woohoo';  // adds/replaces in query string param b=woohoo
+
+if (u.query.a instanceof Array) { // the way to add a parameter
+    u.query.a.push(4); // now it's "a=1&a=2&a=3&a=4&b=woohoo"
+}
+
+else { // if not an array but scalar value here is a way how to convert to array
+    u.query.a = [u.query.a];
+    u.query.a.push(8)
+}
+
+
+// The way to remove the parameter:
+delete u.query.a;
+// or:
+delete u.query["a"];
+
+// If you need to remove all query string params:
+console.log(u.clearQuery());
+console.log(u.queryLength());
+console.log(u.isEmptyQuery());
+
+// Lookup URL parts:
+console.log(
+    'protocol = ' + u.protocol + '\n' +
+    'user = ' + u.user + '\n' +
+    'pass = ' + u.pass + '\n' +
+    'host = ' + u.host + '\n' +
+    'port = ' + u.port + '\n' +
+    'path = ' + u.path + '\n' +
+    'query = ' + u.query + '\n' +
+    'hash = ' + u.hash
+);
+
+// Manipulating URL parts
+u.path = '/some/new/path'; // the way to change URL path
+u.protocol = 'https'; // the way to force https protocol on the source URL
+
+// inject into string
+var str = '<a href="' + u + '">My Cool Link</a>';
+
+// or use in DOM context
+var a = document.createElement('a');
+a.href = u.toString();
+a.innerHTML = 'test';
+document.body.appendChild(a);
+
+// Stringify
+var su1 = u + '';
+var su2 = String(u);
+var su3 = u.toString();
+// NOTE, that usually it will be done automatically, so only in special
+//       cases direct stringify is required

domurl/domurl.d.ts

@@ -0,0 +1,30 @@
+// Type definitions for domurl
+// Project: https://github.com/Mikhus/domurl
+// Definitions by: Mikhus <ttps://github.com/Mikhus>
+// Definitions: https://github.com/Mikhus/DefinitelyTyped
+
+declare class QueryString {
+    constructor(qs?: string);
+    toString: () => string;
+}
+
+declare class Url<T> {
+    constructor(url?: string);
+    query: T;
+    protocol: string;
+    user: string;
+    pass: string;
+    host: string;
+    port: string;
+    path: string;
+    hash: string;
+    href: string;
+    toString: () => string;
+    encode: (s: string) => string;
+    decode: (s: string) => string;
+    isAbsolute: () => boolean;
+    paths: (paths?: [string]) => [string];
+    isEmptyQuery: () => boolean;
+    queryLength: () => number;
+    clearQuery: () => Url<T>;
+}

dustjs-linkedin/dustjs-linkedin.d.ts

@@ -89,7 +89,7 @@ declare module "dustjs-linkedin" {
         * Registers an event listener. Streams accept a single listener for a given event.
         * @param evt the event. Possible values are data, end, error (maybe more, look in the source).
         */
-        on(evt: string, callback: (data?: any) => any);
+        on(evt: string, callback: (data?: any) => any): this;
 
         pipe(stream: Stream): Stream;
     }
@@ -126,8 +126,8 @@ declare module "dustjs-linkedin" {
     * @param name the template name.
     * @param context a plain object or an instance of dust.Context.
     */
-    export function render(name: string, context: any, callback: (err: any, out: string) => any);
-    export function render(name: string, context: Context, callback: (err: any, out: string) => any);
+    export function render(name: string, context: any, callback: (err: any, out: string) => any): void;
+    export function render(name: string, context: Context, callback: (err: any, out: string) => any): void;
 
     /**
     * Compiles and renders source, invoking callback on completion. If no callback is supplied this function returns a Stream object. Use this function when precompilation is not required.

electron-notifications/electron-notifications-tests.ts

@@ -0,0 +1,13 @@
+/// <reference path="./electron-notifications.d.ts" />
+
+import * as notifier from 'electron-notifications';
+
+const data: ElectronNotifications.NotifierOptions = {
+  message: 'message',
+  icon: 'icon',
+  buttons: ['ok', 'cancel']
+};
+const notification = notifier.notify('title', data);
+notification.on('clicked', () => { console.log('clicked') });
+notification.on('swipedRight', () => { console.log('swipedRight') });
+notification.on('buttonClicked', (text) => { console.log(`buttonClicked: ${text}`) });

electron-notifications/electron-notifications.d.ts

@@ -0,0 +1,41 @@
+// Type definitions for electron-notifications v0.0.3
+// Project: https://github.com/blainesch/electron-notifications
+// Definitions by: Daniel Pereira <https://github.com/djpereira>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../github-electron/github-electron.d.ts" />
+
+declare namespace ElectronNotifications {
+
+  interface NotifierOptions {
+
+    /** A message to display under the title. */
+    message?: string,
+
+    /** The absolute URL of a icon displayed to the left of the text. */
+    icon?: string,
+
+    /** One or two buttons to display on the right of the notification. */
+    buttons?: string[]
+  }
+
+  class NotificationWindow extends Electron.BrowserWindow {
+
+    /** When the notification was clicked, but not dragged. This usually does the default action, or closes the notification. */
+    on(event: 'clicked', listener: Function): this;
+
+    /** When the notification has been swiped to the right. This usually indiciated the user wants to dismiss the notification. */
+    on(event: 'swipedRight', listener: Function): this;
+
+    /** When any one of the buttons are clicked, it will trigger a buttonClicked event, and pass the text that was clicked to the handler. */
+    on(event: 'buttonClicked', listener: (text: string) => void): this;
+
+    on(event: string, listener: Function): this;
+  }
+
+}
+
+/** A node module for sending notifications in electron applications */
+declare module 'electron-notifications' {
+  export function notify(title: string, data?: ElectronNotifications.NotifierOptions): ElectronNotifications.NotificationWindow;
+}

electron-notify/electron-notify-tests.ts

@@ -0,0 +1,26 @@
+/// <reference path="./electron-notify.d.ts" />
+
+import * as eNotify from 'electron-notify';
+
+eNotify.setConfig({
+  appIcon: 'images/otherIcon.png',
+  displayTime: 6000,
+  defaultStyleText: {
+    color: '#FF0000',
+    fontWeight: 'bold'
+  }
+});
+
+eNotify.notify({
+  title: 'Title',
+  text: 'Some text',
+  image: 'path/to/image.png',
+  url: 'http://google.de',
+  sound: 'notification.wav',
+  onClickFunc: (event) => {
+    console.log('onClick ' + event.id);
+    event.closeNotification('onClick');
+  },
+  onShowFunc: (event) => { console.log('onShow ' + event.id) },
+  onCloseFunc: (event) => { console.log('onClose ' + event.id) }
+});

electron-notify/electron-notify.d.ts

@@ -0,0 +1,64 @@
+// Type definitions for electron-notify v0.1.0
+// Project: https://github.com/hankbao/electron-notify
+// Definitions by: Daniel Pereira <https://github.com/djpereira>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../github-electron/github-electron.d.ts" />
+
+/** Nice and simple notifications for electron apps */
+declare module 'electron-notify' {
+
+  export interface ICustomConfig {
+    width?: number,
+    height?: number,
+    padding?: number,
+    borderRadius?: number,
+    displayTime?: number,
+    animationSteps?: number,
+    animationStepMs?: number,
+    animateInParallel?: boolean,
+    appIcon?: string,
+    pathToModule?: string,
+    logging?: boolean,
+    defaultWindow?: Electron.BrowserWindowOptions,
+    defaultStyleContainer?: any,
+    defaultStyleAppIcon?: any,
+    defaultStyleImage?: any,
+    defaultStyleClose?: any,
+    defaultStyleText?: any
+  }
+
+  export interface ICloseNotificationEvent {
+    event: 'close' | 'show' | 'click',
+    id: number
+  }
+
+  export interface INotificationEvent extends ICloseNotificationEvent {
+    closeNotification: (reason: any) => void,
+  }
+
+  export interface INotification {
+    title: string,
+    text?: string,
+    image?: string,
+    url?: string,
+    sound?: string,
+    onClickFunc?: (event: INotificationEvent) => void,
+    onShowFunc?: (event: INotificationEvent) => void,
+    onCloseFunc?: (event: ICloseNotificationEvent) => void
+  }
+
+  /** Change some config options. Can be run multiple times, also between notify()-calls to change electron-notifys behaviour. */
+  export function setConfig(customConfig: ICustomConfig): void;
+
+  /** Displays new notification. */
+  export function notify(notification: INotification): void;
+
+  /** Clears the animation queue and closes all windows opened by electron-notify. Call this to clean up before quiting your app. */
+  export function closeAll(): void;
+
+  export function getTemplatePath(): string;
+
+  export function setTemplatePath(path: string): void;
+
+}

epub/epub-tests.ts

@@ -0,0 +1,9 @@
+/// <reference path="epub.d.ts" />
+import EPub = require("epub");
+
+var epub = new EPub("./file.epub");
+epub.on("end", function(){
+	epub.getChapter("chapter_id", function(err: Error, text: string) {});
+});
+
+epub.parse();

epub/epub.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for epub
+// Project: https://github.com/julien-c/epub
+// Definitions by: Julien Chaumond <https://github.com/julien-c>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+/**
+ *  new EPub(fname[, imageroot][, linkroot])
+ *  - fname (String): filename for the ebook
+ *  - imageroot (String): URL prefix for images
+ *  - linkroot (String): URL prefix for links
+ *
+ *  Creates an Event Emitter type object for parsing epub files
+ *
+ *      var epub = new EPub("book.epub");
+ *      epub.on("end", function () {
+ *           console.log(epub.spine);
+ *      });
+ *      epub.on("error", function (error) { ... });
+ *      epub.parse();
+ *
+ *  Image and link URL format is:
+ *
+ *      imageroot + img_id + img_zip_path
+ *
+ *  So an image "logo.jpg" which resides in "OPT/" in the zip archive
+ *  and is listed in the manifest with id "logo_img" will have the
+ *  following url (providing that imageroot is "/images/"):
+ *
+ *      /images/logo_img/OPT/logo.jpg
+ **/
+declare module "epub" {
+	
+	import {EventEmitter} from "events";
+	
+	interface TocElement {
+		level: number;
+		order: number;
+		title: string;
+		id: string;
+		href?: string;
+	}
+	
+	class EPub extends EventEmitter {
+		constructor(epubfile: string, imagewebroot?: string, chapterwebroot?: string);
+		
+		metadata: Object;
+		manifest: Object;
+		spine: Object;
+		flow: Array<Object>;
+		toc: Array<TocElement>;
+		
+		parse(): void;
+		
+		getChapter(chapterId: string, callback: (error: Error, text: string) => void): void;
+		
+		getChapterRaw(chapterId: string, callback: (error: Error, text: string) => void): void;
+		
+		getImage(id: string, callback: (error: Error, data: Buffer, mimeType: string) => void): void;
+		
+		getFile(id: string, callback: (error: Error, data: Buffer, mimeType: string) => void): void;
+	}
+	
+	export = EPub;
+}

eventemitter2/eventemitter2.d.ts

@@ -43,7 +43,7 @@ declare class EventEmitter2 {
      * @param event
      * @param listener
      */
-    on(event: string, listener: Function): EventEmitter2;
+    on(event: string | string[], listener: Function): EventEmitter2;
 
     /**
      * Adds a listener that will be fired when any event is emitted.
@@ -128,7 +128,7 @@ declare class EventEmitter2 {
      * @param event
      * @param args
      */
-    emit(event: string, ...args: any[]): boolean;
+    emit(event: string | string[], ...args: any[]): boolean;
 
     /**
      * Execute each of the listeners that may be listening for the specified event name in order with the list of arguments.
@@ -156,7 +156,7 @@ declare module "eventemitter2" {
          * @param event
          * @param listener
          */
-        on(event: string, listener: Function): EventEmitter2;
+        on(event: string | string[], listener: Function): EventEmitter2;
 
         /**
          * Adds a listener that will be fired when any event is emitted.
@@ -241,7 +241,7 @@ declare module "eventemitter2" {
          * @param event
          * @param args
          */
-        emit(event: string, ...args: any[]): boolean;
+        emit(event: string | string[], ...args: any[]): boolean;
 
         /**
          * Execute each of the listeners that may be listening for the specified event name in order with the list of arguments.

express-serve-static-core/express-serve-static-core.d.ts

@@ -22,7 +22,7 @@ declare module "express-serve-static-core" {
     }
 
     interface RequestHandler {
-        (req: Request, res: Response, next: NextFunction): any;
+        (req: Request, res: Response, next?: NextFunction): any;
     }
 
     interface ErrorRequestHandler {
@@ -117,7 +117,7 @@ declare module "express-serve-static-core" {
     interface CookieOptions {
         maxAge?: number;
         signed?: boolean;
-        expires?: Date;
+        expires?: Date | boolean;
         httpOnly?: boolean;
         path?: string;
         domain?: string;

express-session/express-session.d.ts

@@ -30,7 +30,7 @@ declare namespace Express {
     secure?: boolean;
     httpOnly: boolean;
     domain?: string;
-    expires: Date;
+    expires: Date | boolean;
     serialize: (name: string, value: string) => string;
   }
 }

express-validator/express-validator-tests.ts

@@ -15,19 +15,23 @@ app.post('/:urlparam', function(req: express.Request, res: express.Response) {
   // Similarly checkParams only checks in req.params (URL params) and
   // checkQuery only checks req.query (GET params).
   req.checkBody('postparam', 'Invalid postparam').notEmpty().isInt();
-  req.checkParams('urlparam', 'Invalid urlparam').isAlpha();
+  req.checkParams('urlparam', 'Invalid urlparam').isAlpha().matches(/test?/i).matches('test?', 'i');
   req.checkQuery('getparam', 'Invalid getparam').isInt();
-  req.checkHeader('testHeader', 'Invalid testHeader').isLowercase().isUppercase();
-  req.checkFiles('testFiles', 'Invalid testFiles').isUrl();
-
+  req.checkHeaders('testHeader', 'Invalid testHeader').isLowercase().isUppercase();
+  req.checkFiles('testFiles', 'Invalid testFiles').isURL();
 
   // OR assert can be used to check on all 3 types of params.
   // req.assert('postparam', 'Invalid postparam').notEmpty().isInt();
   // req.assert('urlparam', 'Invalid urlparam').isAlpha();
   // req.assert('getparam', 'Invalid getparam').isInt();
 
-  req.sanitize('postparam').toBoolean();
   req.filter('postparam').toBoolean();
+  req.sanitize('postparam').blacklist('t').blacklist(['<script', '</script>']).whitelist('hello').whitelist(['h', 'e', 'l']);
+  req.sanitizeBody('postvar').trim().stripLow().escape();
+  req.sanitizeQuery('queryvar').toDate();
+  req.sanitizeParams('urlparam').toFloat().toInt().toInt(10);
+  req.sanitizeHeaders('header').normalizeEmail();
+  
 
   var errors = req.validationErrors();
   var mappedErrors = req.validationErrors(true);

express-validator/express-validator.d.ts

@@ -1,9 +1,10 @@
-// Type definitions for express-validator 2.9.0
+// Type definitions for express-validator 2.20.4
 // Project: https://github.com/ctavan/express-validator
-// Definitions by: Nathan Ridley <https://github.com/axefrog/>, Jonathan Häberle <http://dreampulse.de>
+// Definitions by: Nathan Ridley <https://github.com/axefrog/>, Jonathan Häberle <http://dreampulse.de>, Peter Harris <https://github.com/codeanimal/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference path="../express/express.d.ts" />
+/// <reference path="../bluebird/bluebird.d.ts" />
 
 // Add RequestValidation Interface on to Express's Request Interface.
 declare namespace Express {
@@ -31,25 +32,33 @@ declare namespace ExpressValidator {
 		param: string;
 	}
 
-	interface ValidatorFunction { (item: string, message: string): Validator; }
+	interface ValidatorFunction { (item: string | {}, message?: string): Validator; }
+	interface ValidatorExtraFunction extends ValidatorFunction { (matchIndex: number, message?: string): Validator; }
 	interface SanitizerFunction { (item: string): Sanitizer; }
 	interface Dictionary<T> { [key: string]: T; }
 
 	export interface RequestValidation {
-		assert: ValidatorFunction;
-		check: ValidatorFunction;
+		assert: ValidatorExtraFunction;
+		validate: ValidatorExtraFunction;
+		check: ValidatorExtraFunction;
 		checkBody: ValidatorFunction;
 		checkFiles: ValidatorFunction;
-		checkHeader: ValidatorFunction;
+		checkHeaders: ValidatorFunction;
 		checkParams: ValidatorFunction;
 		checkQuery: ValidatorFunction;
-		validate: ValidatorFunction;
-
+		
 		filter: SanitizerFunction;
 		sanitize: SanitizerFunction;
-
+		sanitizeBody: SanitizerFunction;
+		sanitizeQuery: SanitizerFunction;
+		sanitizeParams: SanitizerFunction;
+		sanitizeHeaders: SanitizerFunction;
+		
 		onValidationError(errback: (msg: string) => void): void;
-		validationErrors(mapped?: boolean): Dictionary<any> | any[];
+		validationErrors(mapped?: boolean): Dictionary<MappedError> | MappedError[];
+		validationErrors<T>(mapped?: boolean): Dictionary<T> | T[];
+		asyncValidationErrors(mapped?: boolean): Promise<MappedError[] | Dictionary<MappedError>>;
+		asyncValidationErrors<T>(mapped?: boolean): Promise<T[] | Dictionary<T>>;
 	}
 
 	export interface Validator {
@@ -61,12 +70,13 @@ declare namespace ExpressValidator {
 		 * Alias for notRegex()
 		 */
 		not(): Validator;
-		isEmail(): Validator;
+		isEmail(options?:{}): Validator;
 		/**
 		 * Accepts http, https, ftp
 		 */
-		isUrl(): Validator;
-
+		isURL(): Validator;
+		isFQDN(options?: MinMaxOptions): Validator;
+		
 		/**
 		 * Combines isIPv4 and isIPv6
 		 */
@@ -74,8 +84,21 @@ declare namespace ExpressValidator {
 		isIPv4(): Validator;
 		isIPv6(): Validator;
 		isMACAddress(): Validator;
-		isAlpha(): Validator;
-		isAlphanumeric(): Validator;
+		isISBN(version?: number): Validator;
+		isISIN(): Validator;
+		isISO8601(): Validator;
+		isMobilePhone(locale: string): Validator;
+		isMongoId(): Validator;
+		isMultibyte(): Validator;
+		isAlpha(locale?: string): Validator;
+		isAlphanumeric(locale?: string): Validator;
+		isAscii(): Validator;
+		isBase64(): Validator;
+		isBoolean(): Validator;
+		isByteLength(options: MinMaxOptions): Validator;
+		isCurrency(options: {}): Validator;
+		isDataURI(): Validator;
+		isDivisibleBy(num: number): Validator;
 		isNumeric(): Validator;
 		isHexadecimal(): Validator;
 		/**
@@ -85,7 +108,7 @@ declare namespace ExpressValidator {
 		/**
 		 * isNumeric accepts zero padded numbers, e.g. '001', isInt doesn't
 		 */
-		isInt(): Validator;
+		isInt(options?: MinMaxOptions): Validator;
 		isLowercase(): Validator;
 		isUppercase(): Validator;
 		isDecimal(): Validator;
@@ -93,10 +116,12 @@ declare namespace ExpressValidator {
 		 * Alias for isDecimal
 		 */
 		isFloat(): Validator;
+		isFullWidth(): Validator;
+		isHalfWidth(): Validator;
+		isVariableWidth(): Validator;
 		/**
 		 * Check if length is 0
 		 */
-		notNull(): Validator;
 		isNull(): Validator;
 		/**
 		 * Not just whitespace (input.trim().length !== 0)
@@ -104,12 +129,13 @@ declare namespace ExpressValidator {
 		notEmpty(): Validator;
 		equals(equals:any): Validator;
 		contains(str:string): Validator;
-		notContains(str:string): Validator;
+
 		/**
-		 * Usage: regex(/[a-z]/i) or regex('[a-z]','i')
+		 * Usage: matches(/[a-z]/i) or matches('[a-z]','i')
 		 */
-		regex(pattern:string, modifiers:string): Validator;
-		notRegex(pattern:string, modifiers:string): Validator;
+		matches(pattern:string, modifiers?:string): Validator;
+		matches(pattern: RegExp): Validator;
+		
 		/**
 		 * max is optional
 		 */
@@ -117,7 +143,7 @@ declare namespace ExpressValidator {
 		/**
 		 * Version can be 3, 4 or 5 or empty, see http://en.wikipedia.org/wiki/Universally_unique_identifier
 		 */
-		isUUID(version:number): Validator;
+		isUUID(version?:number): Validator;
 		/**
 		 * Alias for isUUID(3)
 		 */
@@ -137,17 +163,20 @@ declare namespace ExpressValidator {
 		/**
 		 * Argument is optional and defaults to today. Comparison is non-inclusive
 		 */
-		isAfter(date:Date): Validator;
+		isAfter(date?:Date): Validator;
 		/**
 		 * Argument is optional and defaults to today. Comparison is non-inclusive
 		 */
-		isBefore(date:Date): Validator;
+		isBefore(date?:Date): Validator;
 		isIn(options:string): Validator;
 		isIn(options:string[]): Validator;
 		notIn(options:string): Validator;
 		notIn(options:string[]): Validator;
 		max(val:string): Validator;
 		min(val:string): Validator;
+		isJSON(): Validator;
+		isLength(options: MinMaxOptions): Validator;
+		isWhitelisted(chars: string): Validator;
 		/**
 		 * Will work against Visa, MasterCard, American Express, Discover, Diners Club, and JCB card numbering formats
 		 */
@@ -155,7 +184,10 @@ declare namespace ExpressValidator {
 		/**
 		 * Check an input only when the input exists
 		 */
-		optional(): Validator;
+		isSurrogatePar(): Validator;
+		
+		optional(options?: { checkFalsy?: boolean }): Validator;
+		withMessage(message: string): Validator;
 	}
 
 	interface Sanitizer {
@@ -165,40 +197,49 @@ declare namespace ExpressValidator {
 		trim(...chars:string[]): Sanitizer;
 		ltrim(...chars:string[]): Sanitizer;
 		rtrim(...chars:string[]): Sanitizer;
-		ifNull(replace:any): Sanitizer;
+		stripLow(keep_new_lines?: boolean): Sanitizer;
 		toFloat(): Sanitizer;
-		toInt(): Sanitizer;
+		toInt(radix?: number): Sanitizer;
 		/**
-		 * True unless str = '0', 'false', or str.length == 0
-		 */
-		toBoolean(): Sanitizer;
-		/**
-		 * False unless str = '1' or 'true'
-		 */
-		toBooleanStrict(): Sanitizer;
-		/**
-		 * Decode HTML entities
+		 * True unless str = '0', 'false', or str.length == 0. In strict mode only '1' and 'true' return true.
 		 */
+		toBoolean(strict?: boolean): Sanitizer;
 		
 		/**
-     		* Convert the input string to a date, or null if the input is not a date.
-     		*/
-    		toDate(): Sanitizer;
-    
-		entityDecode(): Sanitizer;
-		entityEncode(): Sanitizer;
+		* Convert the input string to a date, or null if the input is not a date.
+		*/
+		toDate(): Sanitizer;
+		
 		/**
 		 * Escape &, <, >, and "
 		 */
 		escape(): Sanitizer;
+		
 		/**
-		 * Remove common XSS attack vectors from user-supplied HTML
+		 * Replaces HTML encoded entities with <, >, &, ', " and /.
 		 */
-		xss(): Sanitizer;
+		unescape(): Sanitizer;
+		
+		blacklist(chars: string): Sanitizer;
+		blacklist(chars: string[]): Sanitizer;
+		whitelist(chars: string): Sanitizer;
+		whitelist(chars: string[]): Sanitizer;
+		
+		normalizeEmail(options?: { lowercase?: boolean; remove_dots?: boolean; remove_extensions?: boolean }): Sanitizer;
+		
 		/**
-		 * Remove common XSS attack vectors from images
+		 * !!! XSS sanitization was removed from the library (see: https://github.com/chriso/validator.js#xss-sanitization)
 		 */
-		xss(fromImages:boolean): Sanitizer;
 	}
-
+	
+	interface MappedError {
+		param: string;
+		msg: string;
+		value: string;
+	}
+	
+	interface MinMaxOptions {
+		min?: number;
+		max?: number;
+	}
 }

express/express-tests.ts

@@ -1,4 +1,5 @@
 /// <reference path="express.d.ts" />
+/// <reference path="../node/node.d.ts" />
 
 import * as express from 'express';
 var app = express();
@@ -91,3 +92,10 @@ app.listen(3000);
 
 const next: express.NextFunction = () => {};
 const nextWithArgument: express.NextFunction = (err: any) => {};
+
+/**
+ * The express.Application is compatible with http.createServer
+ */
+
+import * as http from 'http';
+http.createServer(app);

fs-extra-promise/fs-extra-promise.d.ts

@@ -6,7 +6,7 @@
 // Imported from: https://github.com/soywiz/typescript-node-definitions/fs-extra.d.ts via TSD fs-extra definition
 
 ///<reference path="../node/node.d.ts"/>
-///<reference path="../bluebird/bluebird.d.ts"/>
+///<reference path="../bluebird/bluebird-2.0.d.ts"/>
 
 declare module "fs-extra-promise" {
 	import stream = require("stream");

github-electron/electron-tests.ts

@@ -1,7 +1,7 @@
-/// <reference path="electron-prebuilt.d.ts" />
+/// <reference path="electron.d.ts" />
 /// <reference path="../node/node.d.ts" />
 
-import electron = require('electron-prebuilt');
+import electron = require('electron');
 import child_process = require('child_process');
 
 child_process.spawn(electron);

github-electron/electron.d.ts

@@ -1,9 +1,9 @@
-// Type definitions for electron-prebuilt 0.30.1
-// Project: https://github.com/mafintosh/electron-prebuilt
+// Type definitions for electron 1.3.3
+// Project: https://github.com/electron-userland/electron-prebuilt
 // Definitions by: rhysd <https://github.com/rhysd>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare module 'electron-prebuilt' {
+declare module 'electron' {
 	var electron: string;
 	export = electron;
 }

github-electron/github-electron.d.ts

@@ -4766,6 +4766,10 @@ declare namespace Electron {
 		 * @returns Whether the web page is destroyed.
 		 */
 		isDestroyed(): boolean;
+		/**
+		 * @returns Whether the web page is focused.
+		 */
+		isFocused(): boolean;
 		/**
 		 * @returns Whether guest page is still loading resources.
 		 */

google-earth/google-earth-tests.ts

@@ -0,0 +1,131 @@
+/// <reference path="google-earth.d.ts" />
+
+google.load("earth", "1", {"other_params":"sensor=true_or_false"});
+
+google.earth.createInstance("map3d", initCB, failureCB);
+
+function failureCB(error: any) {}
+
+function initCB(ge: google.earth.GEPlugin) {
+
+  ge.getWindow().setVisibility(true);
+
+
+  // Create the placemark.
+  var placemark = ge.createPlacemark('');
+  placemark.setName("placemark");
+
+  // Set the placemark's location.  
+  var point = ge.createPoint('');
+  point.setLatitude(12.345);
+  point.setLongitude(54.321);
+  placemark.setGeometry(point);
+
+  // Create a style map.
+  var styleMap = ge.createStyleMap('');
+
+  // Create normal style for style map.
+  var normalStyle = ge.createStyle('');
+	var normalIcon = ge.createIcon('');
+  normalIcon.setHref('http://maps.google.com/mapfiles/kml/paddle/red-circle.png');
+  normalStyle.getIconStyle().setIcon(normalIcon);
+
+  // Create highlight style for style map.
+  var highlightStyle = ge.createStyle('');
+  var highlightIcon = ge.createIcon('');
+  highlightIcon.setHref('http://google-maps-icons.googlecode.com/files/girlfriend.png');
+  highlightStyle.getIconStyle().setIcon(highlightIcon);
+  highlightStyle.getIconStyle().setScale(5.0);
+
+  styleMap.setNormalStyle(normalStyle);
+  styleMap.setHighlightStyle(highlightStyle);
+
+  // Apply stylemap to a placemark.
+  placemark.setStyleSelector(styleMap);
+
+  //Add the placemark to Earth.
+  ge.getFeatures().appendChild(placemark);
+
+
+  // balloons
+  var balloon = ge.createHtmlDivBalloon('');
+  balloon.setFeature(placemark);
+  var div = document.createElement('DIV');
+  div.innerHTML = 'Any <em>HTML</em>, CSS, or JavaScript goes here.';
+  balloon.setContentDiv(div);
+  ge.setBalloon(balloon);
+
+    // Create the ScreenOverlay
+  var screenOverlay = ge.createScreenOverlay('');
+
+  // Specify a path to the image and set as the icon
+  var icon = ge.createIcon('');
+  icon.setHref('http://www.google.com/intl/en_ALL/images/logo.gif');
+  screenOverlay.setIcon(icon);
+
+  // Set the ScreenOverlay's position in the window
+  screenOverlay.getOverlayXY().setXUnits(ge.UNITS_PIXELS);
+  screenOverlay.getOverlayXY().setYUnits(ge.UNITS_PIXELS);
+  screenOverlay.getOverlayXY().setX(200);
+  screenOverlay.getOverlayXY().setY(200);
+
+  // Set the overlay's size in pixels
+  screenOverlay.getSize().setXUnits(ge.UNITS_PIXELS);
+  screenOverlay.getSize().setYUnits(ge.UNITS_PIXELS);
+  screenOverlay.getSize().setX(250);
+  screenOverlay.getSize().setY(75);
+
+  // Specify the point in the image around which to rotate
+  screenOverlay.getRotationXY().setXUnits(ge.UNITS_FRACTION);
+  screenOverlay.getRotationXY().setYUnits(ge.UNITS_FRACTION);
+  screenOverlay.getRotationXY().setX(0.5);
+  screenOverlay.getRotationXY().setY(0.5);
+
+  // Rotate the overlay
+  screenOverlay.setRotation(25);
+
+  // Add the ScreenOverlay to Earth
+  ge.getFeatures().appendChild(screenOverlay);
+
+
+  // network link
+  var link = ge.createLink('');
+  var href = 'http://code.google.com/'
+             + 'apis/earth/documentation/samples/kml_example.kml'
+  link.setHref(href);
+
+  var networkLink = ge.createNetworkLink('');
+  networkLink.set(link, true, true); // Sets the link, refreshVisibility, and flyToView
+
+  ge.getFeatures().appendChild(networkLink);
+
+  // Get the current view.
+  var lookAt = ge.getView().copyAsLookAt(ge.ALTITUDE_RELATIVE_TO_GROUND);
+
+  // Set new latitude and longitude values.
+  lookAt.setLatitude(36.584207);
+  lookAt.setLongitude(-121.754322);
+
+  // Update the view in Google Earth.
+  ge.getView().setAbstractView(lookAt);
+
+  // time 
+  ge.getTime().getControl().setVisibility(ge.VISIBILITY_SHOW);
+  ge.getTime().setHistoricalImageryEnabled(true);
+  var extents = ge.getTime().getControl().getExtents();
+  var begin = extents.getBegin().get();
+  var end = extents.getEnd().get();
+
+  // tour
+  ge.getTourPlayer().play();
+
+
+  // controls
+  ge.getNavigationControl().getScreenXY().setXUnits(ge.UNITS_INSET_PIXELS);
+  ge.getNavigationControl().getScreenXY().setYUnits(ge.UNITS_PIXELS);
+
+
+  // sky
+  ge.getOptions().setMapType(ge.MAP_TYPE_SKY);
+  ge.getOptions().setMapType(ge.MAP_TYPE_EARTH);
+}

graphene-pk11/graphene-pk11-tests.ts

@@ -1,8 +1,6 @@
 /// <reference path="./graphene-pk11.d.ts" />
 
 import * as graphene from "graphene-pk11";
-
-// Example of Hashing from README.MD <https://github.com/PeculiarVentures/graphene#hashing>
 let Module = graphene.Module;
 
 let lib = "/usr/local/lib/softhsm/libsofthsm2.so";
@@ -13,13 +11,44 @@ mod.initialize();
 let slot = mod.getSlots(0);
 if (slot.flags & graphene.SlotFlag.TOKEN_PRESENT) {
     let session = slot.open();
+    session.login("12345");
 
-    let digest = session.createDigest("sha1");
-    digest.update("simple text 1");
-    digest.update("simple text 2");
-    let hash = digest.final();
+    // generate EC key
+    let keys = session.generateKeyPair(graphene.KeyGenMechanism.ECDSA, {
+        keyType: graphene.KeyType.ECDSA,
+        token: false,
+        derive: true,
+        paramsECDSA: graphene.NamedCurve.getByName("secp192r1").value
+    }, {
+            keyType: graphene.KeyType.ECDSA,
+            token: false,
+            derive: true
+        });
 
-    console.log("Hash SHA1:", hash.toString("hex")); // Hash SHA1: e1dc1e52e9779cd69679b3e0af87d2e288190d34 
+    // derive algorithm
+    let alg = {
+        name: "ECDH1_DERIVE",
+        params: new graphene.EcdhParams(
+            graphene.EcKdf.SHA1,
+            null,
+            keys.publicKey.getAttribute({ pointEC: null }).pointEC)
+    };
+
+    // Template for derived key
+    let template = {
+        "class": graphene.ObjectClass.SECRET_KEY,
+        "token": false,
+        "keyType": graphene.KeyType.AES,
+        "valueLen": 256 / 8,
+        "encrypt": true,
+        "decrypt": true
+    };
+
+    // Key derivation
+    let dKey = session.deriveKey(alg, keys.privateKey, template);
+    console.log("Derived key handle:", dKey.handle);
+
+    session.logout();
     session.close();
 }
 else {

gulp-rename/gulp-rename-tests.ts

@@ -3,6 +3,9 @@
 import gulp = require("gulp");
 import rename = require("gulp-rename");
 
+// Test that new import syntax works
+import * as newRename from 'gulp-rename';
+
 // rename via string
 gulp.src("./src/main/text/hello.txt")
     .pipe(rename("main/text/ciao/goodbye.md"))
@@ -26,4 +29,4 @@ gulp.src("./src/main/text/hello.txt", { base: process.cwd() })
         suffix: "-hola",
         extname: ".md"
     }))
-    .pipe(gulp.dest("./dist")); // ./dist/main/text/ciao/bonjour-aloha-hola.md
+    .pipe(gulp.dest("./dist")); // ./dist/main/text/ciao/bonjour-aloha-hola.md

gulp-rename/gulp-rename.d.ts

@@ -20,5 +20,12 @@ declare module "gulp-rename" {
     function rename(name: string): NodeJS.ReadWriteStream;
     function rename(callback: (path: ParsedPath) => any): NodeJS.ReadWriteStream;
     function rename(opts: Options): NodeJS.ReadWriteStream;
+
+    /**
+     * This is required as per:
+     * https://github.com/Microsoft/TypeScript/issues/5073
+     */
+    namespace rename {}
+
     export = rename;
-}
+}

halfred/halfred-tests.ts

@@ -0,0 +1,13 @@
+/// <reference path="./halfred.d.ts" />
+
+// run test with: $ tsc --noImplicitAny --target es6 --module commonjs halfred-tests.ts
+import { parse } from 'halfred'; // require('halfred');
+let resource = parse({foo: "bar", "_links": { "self": { href: "fooo" }}});
+console.log(resource);
+
+let allLinks = resource.allLinks();
+for (let key in allLinks) {
+  let link = allLinks[key];
+
+  console.log(link[0].href);
+}

halfred/halfred.d.ts

@@ -0,0 +1,247 @@
+// Type definitions for Halfred v1.0.0
+// Project: https://github.com/basti1302/halfred
+// Definitions by: David Herges <https://github.com/dherges>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+declare module "halfred" {
+
+  /**
+   * halfred.parse(object) returns a Resource object.
+   *
+   * @see https://github.com/basti1302/halfred#usage
+   */
+  export function parse(object: any): Resource;
+
+  /** @see https://github.com/basti1302/halfred#enabledisable-validation */
+  export function enableValidation(flag: boolean): void;
+
+  /** @see https://github.com/basti1302/halfred#enabledisable-validation */
+  export function disableValidation(): void;
+
+  /** @see https://github.com/basti1302/halfred#resource-api */
+  export interface Resource {
+
+    /**
+     * Returns an object which has an array for each link that was present in the source object.
+     * See below why each link is represented as an array.
+     */
+    allLinkArrays(): LinkCollection;
+
+    /** Alias for allLinkArrays() */
+    allLinks(): LinkCollection;
+
+    /**
+     * Returns the array of links for the given key, or null if there are no links for this key.
+     */
+    linkArray(key: string): Link[];
+
+    /**
+     * Returns the first element of the array of links for the given key or null if there are no
+     * links for this key.
+     */
+    link(key: string): Link;
+
+    /**
+     * Returns an object which has an array for each embedded resource that was present in the
+     * source object.
+     * See below why each embedded resource is represented as an array. Each element of any of
+     * this arrays is in turn a Resource object.
+     */
+    allEmbeddedResourceArrays(): ResourceCollection;
+
+    /** Alias for allEmbeddedResourceArrays() */
+    allEmbeddedArrays(): ResourceCollection;
+
+    /** Alias for allEmbeddedResourceArrays() */
+    allEmbeddedResources(): ResourceCollection;
+
+    /**
+     * Returns the array of embedded resources for the given key, or null if there are no embedded
+     * resources for this key. Each element of this arrays is in turn a Resource object.
+     */
+    embeddedResourceArray(key: string): Resource[];
+
+    /** Alias for embeddedResourceArray() */
+    embeddedArray(key: string): Resource[];
+
+    /**
+     * Returns the first element of the array of embedded resources for the given key or null if
+     * there are no embedded resources for this key. The returend object is a Resource object.
+     */
+    embeddedResource(key: string): Resource;
+
+    /** Alias for embeddedResource(key) */
+    embedded(key: string): Resource;  
+
+    /**
+     * Returns the unmodified, original object that was parsed to this resource. This is rather
+     * uninteresting for the source object you give to the parse method (because you probably
+     * still have a reference to the source object) but it is a convenient way to get the part of
+     * the source object that corresponds to an embedded resource.
+     */
+    original(): any;
+
+    /**
+     * Returns true if the resource has any CURIEs (Compact URIs).
+     *
+     * @see http://www.w3.org/TR/2010/NOTE-curie-20101216/
+     */
+    hasCuries(): boolean;
+
+    /**
+     * Returns the array of CURIEs. Each object in the array is a link object, which means it
+     * can be templated etc. See below for the link object API.
+     */
+    curieArray(): Link[];
+
+    /**
+     * Returns the curie with the given name, if any. The returned object is a link object, which
+     * means it can be templated etc. See below for link object API.
+     */
+    curie(name: string): Link;
+
+    /**
+     * Returns the compact URI for the given full URL, if any
+     */
+    reverseResolveCurie(fullUrl: string): string;
+
+    /**
+     * Returns all validation issues. Validation issues are only gathered if validation has been
+     * turned on by calling ``halfred.enableValidation()`` before calling ``halfred.parse``.
+     */
+    validationIssues(): any;
+
+    /**
+     * Alias for validationIssues()
+     */
+    validation(): any;
+
+    /*
+    XX ... think we should NOT try to represent these things in TypeScript.
+
+    In addition to the methods mentioned here, resource has all properties of the source object.
+    This is also true for embedded Resource objects. The non-HAL properties (that is, any
+    property except _links and _embedded) are copied over to the Resource object. This is always
+    a shallow copy, so modifying the a non-HAL property in the Resource object might also alter
+    the source object and vice versa.
+
+    The Resource object also has the properties _links and _embedded but they might differ from
+    the _links/_embedded properties in the source object (Halfred applies some normalization to
+    them). These are not intended to be accessed by clients directly, instead, use the provided
+    methods to work with links and embedded resources.
+    */
+  }
+
+  /** @see https://github.com/basti1302/halfred#links-and-embedded-resources */
+  interface ResourceCollection {
+    [key: string]: Resource[];
+  }
+
+  /** @see https://github.com/basti1302/halfred#links-and-embedded-resources */
+  interface LinkCollection {
+    [rel: string]: Link[]
+  }
+
+  /**
+   * A Link Object represents a hyperlink from the containing resource to a URI.
+   *
+   * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5
+   */
+  interface Link {
+
+    /**
+     * The "href" property is REQUIRED.
+     *
+     * Its value is either a URI [RFC3986] or a URI Template [RFC6570].
+     *
+     * If the value is a URI Template then the Link Object SHOULD have a
+     * "templated" attribute whose value is true.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.1
+     */
+    href: string;
+
+    /**
+     * The "templated" property is OPTIONAL.
+     *
+     * Its value is boolean and SHOULD be true when the Link Object's "href"
+     * property is a URI Template.
+     *
+     * Its value SHOULD be considered false if it is undefined or any other
+     * value than true.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.2
+     */
+    templated?: boolean;
+
+    /**
+     * The "type" property is OPTIONAL.
+     *
+     * Its value is a string used as a hint to indicate the media type
+     * expected when dereferencing the target resource.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.3
+     */
+    type?: string;
+
+    /**
+     * The "deprecation" property is OPTIONAL.
+     * 
+     * Its presence indicates that the link is to be deprecated (i.e.
+     * removed) at a future date.  Its value is a URL that SHOULD provide
+     * further information about the deprecation.
+     *
+     * A client SHOULD provide some notification (for example, by logging a
+     * warning message) whenever it traverses over a link that has this
+     * property.  The notification SHOULD include the deprecation property's
+     * value so that a client manitainer can easily find information about
+     * the deprecation.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.4
+     */
+    deprecation?: string;
+
+    /**
+     * The "name" property is OPTIONAL.
+     *
+     * Its value MAY be used as a secondary key for selecting Link Objects
+     * which share the same relation type.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.5
+     */
+    name?: string;
+
+    /**
+     * The "profile" property is OPTIONAL.
+     *
+     * Its value is a string which is a URI that hints about the profile (as
+     * defined by [I-D.wilde-profile-link]) of the target resource.
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.6
+     */
+    profile?: string;
+
+    /**
+     * The "title" property is OPTIONAL.
+     *
+     * Its value is a string and is intended for labelling the link with a
+     * human-readable identifier (as defined by [RFC5988]).
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.7
+     */
+    title?: string;
+
+    /**
+     * The "hreflang" property is OPTIONAL.
+     *
+     * Its value is a string and is intended for indicating the language of
+     * the target resource (as defined by [RFC5988]).
+     *
+     * @see https://tools.ietf.org/html/draft-kelly-json-hal-08#section-5.8
+     */
+    hreflang?: string;
+
+  }
+
+}

hapi/hapi.d.ts

@@ -1605,6 +1605,9 @@ declare module "hapi" {
 		addEventListener: any;
 		info: IServerConnectionInfo;
 	}
+	
+	type RequestExtPoints = "onRequest" | "onPreResponse" | "onPreAuth" | "onPostAuth" | "onPreHandler" | "onPostHandler" | "onPreResponse";
+	type ServerExtPoints = "onPreStart" | "onPostStart" | "onPreStop" | "onPostStop";
 
 	/** Server http://hapijs.com/api#server
 	 rver object is the main application container. The server manages all incoming connections along with all the facilities provided by the framework. A server can contain more than one connection (e.g. listen to port 80 and 8080).
@@ -2039,8 +2042,9 @@ declare module "hapi" {
 		 server.route({ method: 'GET', path: '/test', handler: handler });
 		 server.start();
 		 // All requests will get routed to '/test'*/
-		ext(event: string, method: (request: Request, reply: IReply, bind?: any) => void, options?: { before: string | string[]; after: string | string[]; bind?: any }): void;
-		ext<T>(event: string, method: (request: Request, reply: IStrictReply<T>, bind?: any) => void, options?: { before: string | string[]; after: string | string[]; bind?: any }): void;
+		ext(event: RequestExtPoints, method: (request: Request, reply: IReply, bind?: any) => void, options?: { before: string | string[]; after: string | string[]; bind?: any }): void;
+		ext<T>(event: RequestExtPoints, method: (request: Request, reply: IStrictReply<T>, bind?: any) => void, options?: { before: string | string[]; after: string | string[]; bind?: any }): void;
+		ext(event: ServerExtPoints, method: (server: Server, next: (err?: any) => void, bind?: any) => void, options?: { before: string | string[]; after: string | string[]; bind?: any }): void;
 
 		/** server.handler(name, method)
 		 Registers a new handler type to be used in routes where:

highcharts/highcharts-modules-exporting.d.ts

@@ -0,0 +1,12 @@
+// Type definitions for Highcharts 4.2.6 (exporting module)
+// Project: http://www.highcharts.com/
+// Definitions by: Maciej Suchecki <http://github.com/mc-suchecki>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="highcharts.d.ts" />
+
+declare var HighchartsExporting: (H: HighchartsStatic) => HighchartsStatic;
+
+declare module "highcharts/modules/exporting" {
+    export = HighchartsExporting;
+}

highcharts/highcharts-modules-no-data-to-display-tests.ts

@@ -0,0 +1,10 @@
+/// <reference path="highcharts-modules-no-data-to-display.d.ts" />
+/// <reference path="highcharts.d.ts" />
+/// <reference path="../jquery/jquery.d.ts" />
+
+function test_NoDataToDisplay() {
+    var chart = $("#container").highcharts();
+    var chartHasData = chart.hasData();
+    chart.hideNoData();
+    chart.showNoData("Custom no data message");
+}

highcharts/highcharts-modules-no-data-to-display.d.ts

@@ -0,0 +1,26 @@
+// Type definitions for Highcharts No Data to Display
+// Project: http://www.highcharts.com/
+// Definitions by: Andrey Zolotin <http://github.com/nitoloz>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+/// <reference path="highcharts.d.ts" />
+interface HighchartsChartObject {
+    /**
+     * Returns true if there are data points within the plot area now
+     * @return {boolean} If chart has any data.
+     * @since 3.0.8
+     */
+    hasData(): boolean;
+
+    /**
+     * Hide the 'No data to display' message added by the no-data-to-display plugin.
+     * @since 3.0.8
+     */
+    hideNoData(): void;
+
+    /**
+     * Display a no-data message.
+     * @param {String} message An optional message to show in place of the default one
+     * @since 3.0.8
+     */
+    showNoData(message?: string): void;
+}

highcharts/highcharts-more.d.ts

@@ -0,0 +1,12 @@
+// Type definitions for Highcharts 4.2.6
+// Project: http://www.highcharts.com/
+// Definitions by: Maciej Suchecki <http://github.com/mc-suchecki>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="highcharts.d.ts" />
+
+declare var HighchartsMore: (H: HighchartsStatic) => HighchartsStatic;
+
+declare module "highcharts/highcharts-more" {
+    export = HighchartsMore;
+}

highcharts/highcharts.d.ts

@@ -240,7 +240,7 @@ interface HighchartsPlotBands {
      * Border color for the plot band. Also requires borderWidth to be set.
      * @default null
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * Border width for the plot band. Also requires borderColor to be set.
      * @default 0
@@ -468,6 +468,10 @@ interface HighchartsAxisOptions {
      * @since 4.0
      */
     ceiling?: number;
+    /**
+     * Configure a crosshair that follows either the mouse pointer or the hovered point.
+     */
+    crosshair?: HighchartsCrosshairObject | boolean;
     /**
      * For a datetime axis, the scale will automatically adjust to the appropriate unit. This member gives the default
      * string representations used for each unit. For an overview of the replacement codes, see dateFormat.
@@ -552,7 +556,7 @@ interface HighchartsAxisOptions {
      * The color of the line marking the axis itself.
      * @default '#C0D0E0'.
      */
-    lineColor?: string;
+    lineColor?: string | HighchartsGradient;
     /**
      * The width of the line marking the axis itself.
      * @default 1
@@ -816,7 +820,7 @@ interface HighchartsAxisOptions {
 interface HighchartsColorAxisDataClass {
     from?: number;
     to?: number;
-    color?: string;
+    color?: string | HighchartsGradient;
     name?: string;
 }
 
@@ -902,7 +906,7 @@ interface HighchartsColorAxisOptions {
      * The color of the line marking the axis itself.
      * @default '#C0D0E0'
      */
-    lineColor?: string;
+    lineColor?: string | HighchartsGradient;
     /**
      * The width of the line marking the axis itself.
      * @default 0
@@ -922,7 +926,7 @@ interface HighchartsColorAxisOptions {
          * The color of the marker.
          * @default 'gray'
          */
-        color?: string;
+        color?: string | HighchartsGradient;
     };
     /**
      * The maximum value of the axis in terms of map point values. If null, the max value is automatically calculated.
@@ -1378,7 +1382,7 @@ interface HighchartsShadow {
     /**
      * @default 'black'
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * @default 1
      */
@@ -1487,7 +1491,7 @@ interface HighchartsChartOptions {
      * The color of the outer chart border.
      * @default '#4572A7'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The corner radius of the outer chart border.
      * @default 0
@@ -1717,7 +1721,7 @@ interface HighchartsChartOptions {
 interface HighchartsCSSObject {
     background?: string;
     border?: string;
-    color?: string;
+    color?: string | HighchartsGradient;
     cursor?: string;
     font?: string;
     fontFamily?: string;
@@ -2425,7 +2429,7 @@ interface HighchartsLegendOptions {
      * The color of the drawn border around the legend.
      * @default '#909090'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The border corner radius of the legend.
      * @default 0
@@ -2720,7 +2724,7 @@ interface HighchartsPaneBackground {
     /**
      * @default 'silver'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * @default 1
      */
@@ -2799,7 +2803,7 @@ interface HighchartsDataLabels {
      * The border color for the data label.
      * @since 2.2.1
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The border radius in pixels for the data label.
      * @default 0
@@ -2816,7 +2820,7 @@ interface HighchartsDataLabels {
      * The text color for the data labels.
      * @default null
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * Whether to hide data labels that are outside the plot area. By default, the data label is moved inside the plot
      * area according to the overflow option.
@@ -3062,7 +3066,7 @@ interface HighchartsMarkerState {
      * The color of the point marker's outline. When null, the series' or point's color is used.
      * @default '#FFFFFF', '#000000' for select state
      */
-    lineColor?: string;
+    lineColor?: string | HighchartsGradient;
     /**
      * The width of the point marker's outline.
      * @default 0
@@ -3272,7 +3276,7 @@ interface HighchartsAreaZone {
      * Defines the color of the series.
      * @since 4.1.0
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * A name for the dash style to use for the graph.
      * @since 4.1.0
@@ -3317,7 +3321,7 @@ interface HighchartsRangeDataLabels {
      * @default undefined
      * @since 2.2.1
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The border radius in pixels for the data label.
      * @default 0
@@ -3334,7 +3338,7 @@ interface HighchartsRangeDataLabels {
      * The text color for the data labels.
      * @default null
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * Whether to hide data labels that are outside the plot area. By default, the data label is moved inside the plot
      * area according to the overflow option.
@@ -3467,7 +3471,7 @@ interface HighchartsDial {
      * @default 'black'
      * @since 2.3.0
      */
-    backgroundColor?: string;
+    backgroundColor?: string | HighchartsGradient;
     /**
      * The length of the dial's base part, relative to the total radius or length of the dial.
      * @default '70%'.
@@ -3486,7 +3490,7 @@ interface HighchartsDial {
      * @default 'silver'
      * @since 2.3.0
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The width of the gauge dial border in pixels.
      * @default 0
@@ -3520,14 +3524,14 @@ interface HighchartsPivot {
      * @default 'black'
      * @since 2.3.0
      */
-    backgroundColor?: string;
+    backgroundColor?: string | HighchartsGradient;
     /**
      * The border or stroke color of the pivot. In able to change this, the borderWidth must also be set to something
      * other than the default 0.
      * @default 'silver'
      * @since 2.3.0
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The border or stroke width of the pivot.
      * @default 0
@@ -3550,7 +3554,7 @@ interface HighchartsTreeMapLevel {
      * Can set borderColor on all points which lies on the same level.
      * @since 4.1.0
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * et the dash style of the border of all the point which lies on the level.
      * @since 4.1.0
@@ -3565,7 +3569,7 @@ interface HighchartsTreeMapLevel {
      * Can set a color on all points which lies on the same level.
      * @since 4.1.0
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * Can set the options of dataLabels on each point which lies on the level.
      * @default undefined
@@ -3590,7 +3594,7 @@ interface HighchartsTreeMapLevel {
 }
 
 /**
- * General options for all series types
+ * General options for all series types.
  */
 interface HighchartsSeriesChart {
     /**
@@ -3611,7 +3615,7 @@ interface HighchartsSeriesChart {
      * specified. In bar type series it applies to the bars unless a color is specified per point. The default value is
      * pulled from the options.colors array.
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * Polar charts only. Whether to connect the ends of a line series plot across the extremes.
      * @default true
@@ -3856,7 +3860,7 @@ interface HighchartsAreaChart extends HighchartsSeriesChart {
      * A separate color for the graph line. By default the line takes the color of the series, but the lineColor setting
      * allows setting a separate color for the line without altering the fillColor.
      */
-    lineColor?: string;
+    lineColor?: string | HighchartsGradient;
     /**
      * A separate color for the negative part of the area.
      * @since 3.0
@@ -3898,7 +3902,7 @@ interface HighchartsBarChart extends HighchartsSeriesChart {
      * The color of the border surrounding each column or bar.
      * @default '#FFFFFF'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The corner radius of the border surrounding each column or bar.
      * @default 0
@@ -4259,7 +4263,7 @@ interface HighchartsFunnelChart extends HighchartsSeriesChart {
      * The color of the border surrounding each column or bar.
      * @default '#FFFFFF'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The width of the border surrounding each column or bar.
      * @default 1
@@ -4381,7 +4385,7 @@ interface HighchartsHeatMapChart extends HighchartsSeriesChart {
      * The color of the border surrounding each column or bar.
      * @default '#FFFFFF'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The corner radius of the border surrounding each column or bar.
      * @default 0
@@ -4464,7 +4468,7 @@ interface HighchartsPieChart extends HighchartsSeriesChart {
      * borderless pies.
      * @default '#FFFFFF'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The width of the border surrounding each column or bar.
      * @default 1
@@ -4569,7 +4573,7 @@ interface HighchartsPyramidChart extends HighchartsSeriesChart {
      * The color of the border surrounding each slice
      * @default '#FFFFFF'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The width of the border surrounding each slice
      * @default 1
@@ -4684,7 +4688,7 @@ interface HighchartsTreeMapChart extends HighchartsSeriesChart {
      * The color of the border surrounding each tree map item.
      * @default '#E0E0E0'
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The width of the border surrounding each column or bar.
      * @default 1
@@ -4779,7 +4783,7 @@ interface HighchartsWaterFallChart extends HighchartsBarChart {
      * @default '#333333'
      * @since 3.0
      */
-    lineColor?: string;
+    lineColor?: string | HighchartsGradient;
     /**
      * The color used specifically for positive point columns. When not specified, the general series color is used.
      */
@@ -4830,7 +4834,7 @@ interface HighchartsIndividualSeriesOptions {
      *     specified. In bar type series it applies to the bars unless a color is specified per point. The default
      *     value is pulled from the options.colors array.
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * You can set the cursor to "pointer" if you have click events attached to the series, to signal to the user
      *     that the points and lines can be clicked.
@@ -4945,7 +4949,7 @@ interface HighchartsDataPoint {
      * Individual color for the point. By default the color is pulled from the global colors array.
      * @default undefined
      */
-    color?: string;
+    color?: string | HighchartsGradient;
     /**
      * Serves a purpose only if a colorAxis object is defined in the chart options. This value will decide which color
      * the point gets from the scale of the colorAxis.
@@ -5169,7 +5173,7 @@ interface HighchartsTitleOptions {
 }
 
 interface HighchartsCrosshairObject {
-    color?: string;
+    color?: string | HighchartsGradient;
     width?: number;
     dashStyle?: string; //Solid ShortDash ShortDot ShortDashDot ShortDashDotDot Dot Dash LongDash DashDot LongDashDot LongDashDotDot
     zIndex?: number;
@@ -5196,7 +5200,7 @@ interface HighchartsTooltipOptions extends HighchartsSeriesTooltipOptions {
      * The color of the tooltip border. When null, the border takes the color of the corresponding series or point.
      * @default null
      */
-    borderColor?: string;
+    borderColor?: string | HighchartsGradient;
     /**
      * The radius of the rounded border corners.
      * @default 3
@@ -5598,7 +5602,7 @@ interface HighchartsAxisObject {
      * @param {boolean | HighchartsAnimation} animation When true, the resize will be animated with default animation options. The animation can also be a configuration object with properties duration and easing.
      * @since 1.2.0
      */
-    setExtremes(min?: number, max?: number, redraw?: boolean, animation?: boolean | HighchartsAnimation): void;
+    setExtremes(min?: number, max?: number, redraw?: boolean, animation?: boolean | HighchartsAnimation, eventArguments?: any): void;
     /**
      * Update the title of the axis after render time.
      * @param {HighchartsAxisTitle} title  The new title options on the same format as given in xAxis.title.

inline-css/inline-css.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Philip Spain <https://github.com/philipisapain>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 
 declare module 'inline-css' {
 	import Promise = require('bluebird');

inversify/inversify.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: inversify <https://github.com/inversify>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 
 interface Symbol {
     toString(): string;
@@ -31,9 +31,9 @@ declare namespace inversify {
         export interface Newable<T> {
             new(...args: any[]): T;
         }
-    
+
         export type ServiceIdentifier<T> = (string|Symbol|Newable<T>);
-    
+
         export interface Binding<T> extends Clonable<Binding<T>> {
             guid: string;
             moduleId: string;
@@ -49,66 +49,66 @@ declare namespace inversify {
             scope: number; // BindingScope
             type: number; // BindingType
         }
-    
+
         export interface Factory<T> extends Function {
             (...args: any[]): (((...args: any[]) => T)|T);
         }
-    
+
         export interface FactoryCreator<T> extends Function {
             (context: Context): Factory<T>;
         }
-    
+
         export interface Provider<T> extends Function {
             (): Promise<T>;
         }
-    
+
         export interface ProviderCreator<T> extends Function {
             (context: Context): Provider<T>;
         }
-    
+
         export interface PlanAndResolve<T> {
             (args: PlanAndResolveArgs): T[];
         }
-    
+
         export interface PlanAndResolveArgs {
             multiInject: boolean;
             serviceIdentifier: ServiceIdentifier<any>;
             target: Target;
             contextInterceptor: (contexts: Context) => Context;
         }
-    
+
         export interface Middleware extends Function {
             (next: PlanAndResolve<any>): PlanAndResolve<any>;
         }
-    
+
         export interface Context {
             guid: string;
             kernel: Kernel;
             plan: Plan;
             addPlan(plan: Plan): void;
         }
-    
+
         export interface ReflectResult {
             [key: string]: Metadata[];
         }
-    
+
         export interface Metadata {
             key: string;
             value: any;
         }
-    
+
         export interface Plan {
             parentContext: Context;
             rootRequest: Request;
         }
-    
+
         export interface Planner {
             createContext(kernel: Kernel): Context;
             createPlan(parentContext: Context, binding: Binding<any>, target: Target): Plan;
             getBindings<T>(kernel: Kernel, serviceIdentifier: ServiceIdentifier<T>): Binding<T>[];
             getActiveBindings(parentRequest: Request, target: Target): Binding<any>[];
         }
-    
+
         export interface QueryableString {
             startsWith(searchString: string): boolean;
             endsWith(searchString: string): boolean;
@@ -116,7 +116,7 @@ declare namespace inversify {
             equals(compareString: string): boolean;
             value(): string;
         }
-    
+
         export interface Request {
             guid: string;
             serviceIdentifier: ServiceIdentifier<any>;
@@ -131,7 +131,7 @@ declare namespace inversify {
                 target: Target
             ): Request;
         }
-    
+
         export interface Target {
             guid: string;
             serviceIdentifier: ServiceIdentifier<any>;
@@ -145,11 +145,11 @@ declare namespace inversify {
             matchesNamedTag(name: string): boolean;
             matchesTag(key: string): (value: any) => boolean;
         }
-    
+
         export interface Resolver {
             resolve<T>(context: Context): T;
         }
-    
+
         export interface Kernel {
             guid: string;
             bind<T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
@@ -167,25 +167,25 @@ declare namespace inversify {
             snapshot(): void;
             restore(): void;
         }
-    
+
         export interface Bind extends Function {
             <T>(serviceIdentifier: ServiceIdentifier<T>): BindingToSyntax<T>;
         }
-    
+
         export interface KernelModule {
             guid: string;
             registry: (bind: Bind) => void;
         }
-    
+
         export interface KernelSnapshot {
             bindings: Lookup<Binding<any>>;
             middleware: PlanAndResolve<any>;
         }
-    
+
         export interface Clonable<T> {
             clone(): T;
         }
-    
+
         export interface Lookup<T> extends Clonable<Lookup<T>> {
             add(serviceIdentifier: ServiceIdentifier<any>, value: T): void;
             get(serviceIdentifier: ServiceIdentifier<any>): Array<T>;
@@ -193,22 +193,22 @@ declare namespace inversify {
             removeByModuleId(moduleId: string): void;
             hasKey(serviceIdentifier: ServiceIdentifier<any>): boolean;
         }
-    
+
         export interface KeyValuePair<T> {
             serviceIdentifier: ServiceIdentifier<any>;
             value: Array<T>;
         }
-    
+
         export interface BindingInSyntax<T> {
             inSingletonScope(): BindingWhenOnSyntax<T>;
         }
-    
+
         export interface BindingInWhenOnSyntax<T> extends BindingInSyntax<T>, BindingWhenOnSyntax<T> {}
-    
+
         export interface BindingOnSyntax<T> {
             onActivation(fn: (context: Context, injectable: T) => T): BindingWhenSyntax<T>;
         }
-    
+
         export interface BindingToSyntax<T> {
             to(constructor: { new(...args: any[]): T; }): BindingInWhenOnSyntax<T>;
             toConstantValue(value: T): BindingWhenOnSyntax<T>;
@@ -219,9 +219,9 @@ declare namespace inversify {
             toAutoFactory<T2>(serviceIdentifier: ServiceIdentifier<T2>): BindingWhenOnSyntax<T>;
             toProvider<T2>(provider: ProviderCreator<T2>): BindingWhenOnSyntax<T>;
         }
-    
+
         export interface BindingWhenOnSyntax<T> extends BindingWhenSyntax<T>, BindingOnSyntax<T> {}
-    
+
         export interface BindingWhenSyntax<T> {
             when(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
             whenTargetNamed(name: string): BindingOnSyntax<T>;
@@ -238,7 +238,7 @@ declare namespace inversify {
             whenAnyAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
             whenNoAncestorMatches(constraint: (request: Request) => boolean): BindingOnSyntax<T>;
         }
-    
+
     }
 
     export var Kernel: interfaces.KernelConstructor;

jasmine-node/jasmine-node.d.ts

@@ -7,6 +7,12 @@
 
 declare function it(expectation:string, assertion:(done:(err?:any) => void) => void, timeout?:number):void;
 
+declare namespace jasmine {
+	interface Env {
+		defaultTimeoutInterval: number;
+	}
+}
+
 declare module "jasmine-node" {
     interface ExecuteSpecsOptions {
         specFolders: string[],

java/java-tests.ts

@@ -1,5 +1,5 @@
 ///<reference path="java.d.ts"/>
-///<reference path="../bluebird/bluebird.d.ts"/>
+///<reference path="../bluebird/bluebird-2.0.d.ts"/>
 
 import java = require('java');
 import BluePromise = require('bluebird');

json-editor/json-editor.d.ts

@@ -39,7 +39,7 @@ type JSONEditorOptions<TValue> = {
     /**
      * The icon library to use for the editor.
      */
-    iconlib?: boolean;
+    iconlib?: "bootstrap2" | "bootstrap3" | "foundation2" | "foundation3" | "jqueryui" | "fontawesome3" | "fontawesome4";
     /**
      * If true, objects can only contain properties defined with the properties keyword.
      */
@@ -75,7 +75,7 @@ type JSONEditorOptions<TValue> = {
     /**
      * The CSS theme to use.
      */
-    theme?: string;
+    theme?: "barebones" | "html" | "bootstrap2" | "bootstrap3" | "foundation3" | "foundation4" | "foundation5" | "foundation6" | "jqueryui";
     /**
      * If true, only required properties will be included by default.
      */

jspdf/jspdf-tests.ts

@@ -2,6 +2,8 @@
 
 // From: https://mrrio.github.io/jsPDF/examples/basic.html
 
+import * as jsPDF from 'jspdf';
+
 function test_simple_two_page_document() {
     var doc = new jsPDF();
     doc.text(20, 20, 'Hello world!');

jspdf/jspdf.d.ts

@@ -3,201 +3,207 @@
 // Definitions by: Amber Schühmacher <https://github.com/amberjs>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-declare class jsPDF {
-    constructor(orientation?:any,
-                unit?:string,
-                format?:string,
-                compressPdf?:number);
+declare module 'jspdf' {
+    class jsPDF {
+        constructor(orientation?:any,
+                    unit?:string,
+                    format?:string,
+                    compressPdf?:number);
 
-    CapJoinStyles:any;
-    version:string;
+        CapJoinStyles:any;
+        version:string;
 
-    internal: {
-        'pdfEscape'(text:string, flags:any): any;
-        'getStyle'(style:string) : any;
-        'getFont'(): any;
-        'getFontSize'():number;
-        'getLineHeight'():number;
-        'write'(string1:string):any;
-        'getCoordinateString'(value:number):number;
-        'getVerticalCoordinateString'(value:number):number;
-        'collections':any;
-        'newObject'():number;
-        'newAdditionalObject'():any;
-        'newObjectDeferred'():number;
-        'newObjectDeferredBegin'(oid:number):void;
-        'putStream'(str:string):void;
-        'events':any;
-        'scaleFactor':number;
-        'pageSize': {
-            width:number;
-            height:number;
+        internal: {
+            'pdfEscape'(text:string, flags:any): any;
+            'getStyle'(style:string) : any;
+            'getFont'(): any;
+            'getFontSize'():number;
+            'getLineHeight'():number;
+            'write'(string1:string):any;
+            'getCoordinateString'(value:number):number;
+            'getVerticalCoordinateString'(value:number):number;
+            'collections':any;
+            'newObject'():number;
+            'newAdditionalObject'():any;
+            'newObjectDeferred'():number;
+            'newObjectDeferredBegin'(oid:number):void;
+            'putStream'(str:string):void;
+            'events':any;
+            'scaleFactor':number;
+            'pageSize': {
+                width:number;
+                height:number;
+            };
+            'output'(type:any, options:any):any;
+            'getNumberOfPages'():number;
+            'pages':number[];
+            'out'(string:string):void;
+            'f2'(number:number):number;
+            'getPageInfo'(pageNumberOneBased:number):any;
+            'getCurrentPageInfo'():any;
         };
-        'output'(type:any, options:any):any;
-        'getNumberOfPages'():number;
-        'pages':number[];
-        'out'(string:string):void;
-        'f2'(number:number):number;
-        'getPageInfo'(pageNumberOneBased:number):any;
-        'getCurrentPageInfo'():any;
-    };
-    addPage():jsPDF;
-    setPage(n:number):jsPDF;
-    insertPage(beforePage:number):jsPDF;
-    movePage(targetPage:number, beforePage:number):jsPDF;
-    deletePage(n:number):jsPDF;
-    setDisplayMode(zoom?:string, layout?:string, pmode?:string):jsPDF;
-    text(text:any, x:any, y:any, flags?:any, angle?:any, align?:any):jsPDF;
-    lstext(text:string, x:number, y:number, spacing:number):jsPDF;
-    line(x1:number, y1:number, x2:number, y2:number):any;
-    clip():void;
-    lines(lines:any, x:any, y:any, scale?:any, style?:string, closed?:boolean):jsPDF;
-    rect(x:number, y:number, w:number, h:number, style?:string):jsPDF;
-    triangle(x1:number, y1:number, x2:number, y2:number, x3:number, y3:number, style:string):jsPDF;
-    roundedRect(x:number, y:number, w:number, h:number, rx:number, ry:number, style:string):jsPDF;
-    ellipse(x:number, y:number, rx:number, ry:number, style?:string):jsPDF;
-    circle(x:number, y:number, r:number, style:string):jsPDF;
-    setProperties(properties:any):jsPDF;
-    setFontSize(size:number):jsPDF;
-    setFont(fontName?:string, fontStyle?:string):jsPDF;
-    setFontStyle(style:string):jsPDF;
-    setFontType(style:string):jsPDF;
-    getFontList():any;
-    addFont(postScriptName:string, fontName:string, fontStyle:string):string;
-    setLineWidth(width:number):jsPDF;
-    setDrawColor(ch1:number|string, ch2?:number, ch3?:number, ch4?:number):jsPDF;
-    setFillColor(ch1:number|string, ch2?:number, ch3?:number, ch4?:number):jsPDF;
-    setTextColor(r?:number, g?:number, b?:number):jsPDF;
-    setLineCap(style:string|number):jsPDF;
-    setLineJoin(style:string|number):jsPDF;
-    output(type?:string, options?:any):any;
-    save(filename:string):jsPDF;
+        addPage():jsPDF;
+        setPage(n:number):jsPDF;
+        insertPage(beforePage:number):jsPDF;
+        movePage(targetPage:number, beforePage:number):jsPDF;
+        deletePage(n:number):jsPDF;
+        setDisplayMode(zoom?:string, layout?:string, pmode?:string):jsPDF;
+        text(text:any, x:any, y:any, flags?:any, angle?:any, align?:any):jsPDF;
+        lstext(text:string, x:number, y:number, spacing:number):jsPDF;
+        line(x1:number, y1:number, x2:number, y2:number):any;
+        clip():void;
+        lines(lines:any, x:any, y:any, scale?:any, style?:string, closed?:boolean):jsPDF;
+        rect(x:number, y:number, w:number, h:number, style?:string):jsPDF;
+        triangle(x1:number, y1:number, x2:number, y2:number, x3:number, y3:number, style:string):jsPDF;
+        roundedRect(x:number, y:number, w:number, h:number, rx:number, ry:number, style:string):jsPDF;
+        ellipse(x:number, y:number, rx:number, ry:number, style?:string):jsPDF;
+        circle(x:number, y:number, r:number, style:string):jsPDF;
+        setProperties(properties:any):jsPDF;
+        setFontSize(size:number):jsPDF;
+        setFont(fontName?:string, fontStyle?:string):jsPDF;
+        setFontStyle(style:string):jsPDF;
+        setFontType(style:string):jsPDF;
+        getFontList():any;
+        addFont(postScriptName:string, fontName:string, fontStyle:string):string;
+        setLineWidth(width:number):jsPDF;
+        setDrawColor(ch1:number|string, ch2?:number, ch3?:number, ch4?:number):jsPDF;
+        setFillColor(ch1:number|string, ch2?:number, ch3?:number, ch4?:number):jsPDF;
+        setTextColor(r?:number, g?:number, b?:number):jsPDF;
+        setLineCap(style:string|number):jsPDF;
+        setLineJoin(style:string|number):jsPDF;
+        output(type?:string, options?:any):any;
+        save(filename:string):jsPDF;
 
-    /**
-     * jsPDF plugins below:
-     *
-     *  - AddHTML
-     *  - AddImage
-     *  - Annotations
-     *  - AutoPrint
-     *  - Canvas
-     *  - Cell
-     *  - Context2D
-     *  - FromHTML
-     *  - JavaScript
-     *  - PNG
-     *  - split_text_to_size
-     *  - SVG
-     *  - total_pages
-     */
+        /**
+         * jsPDF plugins below:
+         *
+         *  - AddHTML
+         *  - AddImage
+         *  - Annotations
+         *  - AutoPrint
+         *  - Canvas
+         *  - Cell
+         *  - Context2D
+         *  - FromHTML
+         *  - JavaScript
+         *  - PNG
+         *  - split_text_to_size
+         *  - SVG
+         *  - total_pages
+         */
 
-    // jsPDF plugin: addHTML
-    addHTML(element:any, x:number, y:number, options:any, callback:Function):jsPDF;
-    addHTML(element:any, callback:Function):jsPDF;
+        // jsPDF plugin: addHTML
+        addHTML(element:any, x:number, y:number, options:any, callback:Function):jsPDF;
+        addHTML(element:any, callback:Function):jsPDF;
 
-    // jsPDF plugin: addImage
-    color_spaces:any;
-    decode:any;
-    image_compression:any;
+        // jsPDF plugin: addImage
+        color_spaces:any;
+        decode:any;
+        image_compression:any;
 
-    sHashCode(str:string):any;
-    isString(object:any):boolean;
-    extractInfoFromBase64DataURI(dataURI:string):any[];
-    supportsArrayBuffer():boolean;
-    isArrayBuffer(object:any):boolean;
-    isArrayBufferView(object:any):boolean;
-    binaryStringToUint8Array(binary_string:string):Uint8Array;
-    arrayBufferToBinaryString(buffer:any):string;
-    arrayBufferToBase64(arrayBuffer:ArrayBuffer):string;
-    createImageInfo(data:any, wd:any, ht:any, cs:any, bpc:any, imageIndex:number, alias:any, f?:any, dp?:any, trns?:any, pal?:any, smask?:any):any;
-    addImage(imageData?:any, format?:any, x?:number, y?:number, w?:number, h?:number, alias?:any, compression?:any, rotation?:any):jsPDF;
-    processJPEG(data:any, index:number, alias:any, compression?:any, dataAsBinaryString?:string):any;
-    processJPG():any;
+        sHashCode(str:string):any;
+        isString(object:any):boolean;
+        extractInfoFromBase64DataURI(dataURI:string):any[];
+        supportsArrayBuffer():boolean;
+        isArrayBuffer(object:any):boolean;
+        isArrayBufferView(object:any):boolean;
+        binaryStringToUint8Array(binary_string:string):Uint8Array;
+        arrayBufferToBinaryString(buffer:any):string;
+        arrayBufferToBase64(arrayBuffer:ArrayBuffer):string;
+        createImageInfo(data:any, wd:any, ht:any, cs:any, bpc:any, imageIndex:number, alias:any, f?:any, dp?:any, trns?:any, pal?:any, smask?:any):any;
+        addImage(imageData?:any, format?:any, x?:number, y?:number, w?:number, h?:number, alias?:any, compression?:any, rotation?:any):jsPDF;
+        processJPEG(data:any, index:number, alias:any, compression?:any, dataAsBinaryString?:string):any;
+        processJPG():any;
 
-    // jsPDF plugin: Annotations
-    annotationPlugin:any;
-    createAnnotation(options:any):void;
-    link(x:number, y:number, w:number, h:number, options:any):void;
-    textWithLink(text:string, x:number, y:number, options:any):number;
-    getTextWidth(text:string):number;
-    getLineHeight():number;
+        // jsPDF plugin: Annotations
+        annotationPlugin:any;
+        createAnnotation(options:any):void;
+        link(x:number, y:number, w:number, h:number, options:any):void;
+        textWithLink(text:string, x:number, y:number, options:any):number;
+        getTextWidth(text:string):number;
+        getLineHeight():number;
 
-    // jsPDF plugin: AutoPrint
-    autoPrint():jsPDF;
+        // jsPDF plugin: AutoPrint
+        autoPrint():jsPDF;
 
-    // jsPDF plugin: Canvas
-    canvas: {
-        getContext():any;
-        style:any;
-    };
+        // jsPDF plugin: Canvas
+        canvas: {
+            getContext():any;
+            style:any;
+        };
 
-    // jsPDF plugin: Cell
-    setHeaderFunction(func:Function):void;
-    getTextDimensions(txt:string):any;
-    cellAddPage():void;
-    cellInitialize():void;
-    cell(x:number, y:number, w:number, h:number, txt:string, ln:number, align:string):jsPDF;
-    arrayMax(array:any[], comparisonFn?:Function):number;
-    table(x:number, y:number, data:any, headers:string[], config:any):jsPDF;
-    calculateLineHeight(headerNames:string[], columnWidths:number[], model:any[]):number;
-    setTableHeaderRow(config:any[]):void;
-    printHeaderRow(lineNumber:number, new_page?:boolean):void;
+        // jsPDF plugin: Cell
+        setHeaderFunction(func:Function):void;
+        getTextDimensions(txt:string):any;
+        cellAddPage():void;
+        cellInitialize():void;
+        cell(x:number, y:number, w:number, h:number, txt:string, ln:number, align:string):jsPDF;
+        arrayMax(array:any[], comparisonFn?:Function):number;
+        table(x:number, y:number, data:any, headers:string[], config:any):jsPDF;
+        calculateLineHeight(headerNames:string[], columnWidths:number[], model:any[]):number;
+        setTableHeaderRow(config:any[]):void;
+        printHeaderRow(lineNumber:number, new_page?:boolean):void;
 
-    // jsPDF plugin: Context2D
-    context2d: {
-        pageWrapXEnabled: boolean;
-        pageWrapYEnabled: boolean;
-        pageWrapX: number;
-        pageWrapY: number;
-        f2(number:number):number;
-        fillRect(x:number, y:number, w:number, h:number):void;
-        strokeRect(x:number, y:number, w:number, h:number):void;
-        clearRect(x:number, y:number, w:number, h:number):void;
-        save():void;
-        restore():void;
-        beginPath():void;
-        closePath():void;
-        setFillStyle(style:string):void;
-        setStrokeStyle(style:string):void;
-        fillText(text:string|string[], x:number, y:number, maxWidth:number):void;
-        strokeText(text:string|string[], x:number, y:number, maxWidth:number):void;
-        setFont(font:string):void;
-        setTextBaseline(baseline:string):void;
-        getTextBaseline():string;
-        setLineWidth(width:number):void;
-        setLineCap(style:string):void;
-        setLineJoin(style:string):void;
-        moveTo(x:number, y:number):void;
-        lastBreak: number;
-        pageBreaks: any[];
-        lineTo(x:number, y:number):void;
-        bezierCurveTo(x1:number, y1:number, x2:number, y2:number, x:number, y:number):void;
-        quadraticCurveTo(x1:number, y1:number, x:number, y:number):void;
-        arc(x:number, y:number, radius:number, startAngle:number, endAngle:number, anticlockwise:any):void;
-        drawImage(img:string, x:number, y:number, w:number, h:number, x2?:number, y2?:number, w2?:number, h2?:number):void;
-        stroke():void;
-        fill():void;
-        translate(x:number, y:number):void;
-        measureText(text:string):number;
-    };
+        // jsPDF plugin: Context2D
+        context2d: {
+            pageWrapXEnabled: boolean;
+            pageWrapYEnabled: boolean;
+            pageWrapX: number;
+            pageWrapY: number;
+            f2(number:number):number;
+            fillRect(x:number, y:number, w:number, h:number):void;
+            strokeRect(x:number, y:number, w:number, h:number):void;
+            clearRect(x:number, y:number, w:number, h:number):void;
+            save():void;
+            restore():void;
+            beginPath():void;
+            closePath():void;
+            setFillStyle(style:string):void;
+            setStrokeStyle(style:string):void;
+            fillText(text:string|string[], x:number, y:number, maxWidth:number):void;
+            strokeText(text:string|string[], x:number, y:number, maxWidth:number):void;
+            setFont(font:string):void;
+            setTextBaseline(baseline:string):void;
+            getTextBaseline():string;
+            setLineWidth(width:number):void;
+            setLineCap(style:string):void;
+            setLineJoin(style:string):void;
+            moveTo(x:number, y:number):void;
+            lastBreak: number;
+            pageBreaks: any[];
+            lineTo(x:number, y:number):void;
+            bezierCurveTo(x1:number, y1:number, x2:number, y2:number, x:number, y:number):void;
+            quadraticCurveTo(x1:number, y1:number, x:number, y:number):void;
+            arc(x:number, y:number, radius:number, startAngle:number, endAngle:number, anticlockwise:any):void;
+            drawImage(img:string, x:number, y:number, w:number, h:number, x2?:number, y2?:number, w2?:number, h2?:number):void;
+            stroke():void;
+            fill():void;
+            translate(x:number, y:number):void;
+            measureText(text:string):number;
+        };
 
-    // jsPDF plugin: fromHTML
-    fromHTML(HTML:string | HTMLElement, x:number, y:number, settings?:any, callback?:Function, margins?:any):jsPDF;
+        // jsPDF plugin: fromHTML
+        fromHTML(HTML:string | HTMLElement, x:number, y:number, settings?:any, callback?:Function, margins?:any):jsPDF;
 
-    // jsPDF plugin: JavaScript
-    addJS(txt:string):jsPDF;
+        // jsPDF plugin: JavaScript
+        addJS(txt:string):jsPDF;
 
-    // jsPDF plugin: PNG
-    processPNG(imageData:any, imageIndex:number, alias:string, compression:any, dataAsBinaryString:string):any;
+        // jsPDF plugin: PNG
+        processPNG(imageData:any, imageIndex:number, alias:string, compression:any, dataAsBinaryString:string):any;
 
-    // jsPDF plugin: split_text_to_size
-    getCharWidthsArray(text:string, options?:any):any[];
-    getStringUnitWidth(text:string, options?:any):number;
-    splitTextToSize(text:string, maxlen:number, options?:any):any;
+        // jsPDF plugin: split_text_to_size
+        getCharWidthsArray(text:string, options?:any):any[];
+        getStringUnitWidth(text:string, options?:any):number;
+        splitTextToSize(text:string, maxlen:number, options?:any):any;
 
-    // jsPDF plugin: SVG
-    addSVG(svgtext:string, x:number, y:number, w?:number, h?:number):jsPDF;
+        // jsPDF plugin: SVG
+        addSVG(svgtext:string, x:number, y:number, w?:number, h?:number):jsPDF;
 
-    // jsPDF plugin: total_pages
-    putTotalPages(pageExpression:string):jsPDF;
+        // jsPDF plugin: total_pages
+        putTotalPages(pageExpression:string):jsPDF;
+    }
+    
+    namespace jsPDF {}
+
+    export = jsPDF;
 }

jstree/jstree.d.ts

@@ -1,8 +1,8 @@
-// Type definitions for jsTree v3.3.1 
+// Type definitions for jsTree v3.3.2 
 // Project: http://www.jstree.com/
 // Definitions by: Adam Pluciński <https://github.com/adaskothebeast>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// 1 commit 3b8f55d3797cd299eb36695b62d75c2313a3e3b3 2016-05-10
+// 1 commit bb0473ae8cfc205585b6404ef86f650df2f6996e 2016-08-15
 
 ///<reference path="../jquery/jquery.d.ts" />
 
@@ -465,6 +465,7 @@ interface JSTreeStaticDefaultsContextMenu {
     * * `separator_after` - a boolean indicating if there should be a separator after this item
     * * `_disabled` - a boolean indicating if this action should be disabled
     * * `label` - a string - the name of the action (could be a function returning a string)
+    * * `title` - a string - an optional tooltip for the item
     * * `action` - a function to be executed if this item is chosen, the function will receive 
     * * `icon` - a string, can be a path to an icon or a className, if using an image that is in the current directory use a `./` prefix, otherwise it will be detected as a class
     * * `shortcut` - keyCode which will trigger the action if the menu is open (for example `113` for rename, which equals F2)
@@ -1339,6 +1340,8 @@ interface JSTree extends JQuery {
     * @param  {Boolean} options.no_id do not return ID
     * @param  {Boolean} options.no_children do not include children
     * @param  {Boolean} options.no_data do not include node data
+    * @param  {Boolean} options.no_li_attr do not include LI attributes
+    * @param  {Boolean} options.no_a_attr do not include A attributes
     * @param  {Boolean} options.flat return flat JSON instead of nested
     * @return {Object}
     */
@@ -1882,6 +1885,16 @@ interface JSTreeGetJsonOptions {
     */
     no_data: boolean;
 
+    /** 
+    * do not include LI attributes
+    */
+    no_li_attr: boolean;
+    
+    /**
+    * do not include A attributes
+    */
+    no_a_attr: boolean;
+
     /**
     * return flat JSON instead of nested
     */

karma-fixture/karma-fixture-tests.ts

@@ -0,0 +1,10 @@
+/// <reference path="karma-fixture.d.ts" />
+
+fixture.setBase('fixtures/base/path');
+fixture.load('test1.html', 'test1.json', false);
+fixture.load('test1.html', 'test2.html', 'test1.json');
+fixture.set('<em></em>', true);
+fixture.set('<em></em>', '<strong><strong/>');
+fixture.cleanup();
+fixture.el.firstChild;
+JSON.stringify(fixture.json[0]);

karma-fixture/karma-fixture.d.ts

@@ -0,0 +1,27 @@
+// Type definitions for karma-fixture 0.2.6
+// Project: https://github.com/billtrik/karma-fixture
+// Definitions by: Ezekiel Victor <https://github.com/evictor/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module fixture {
+  var el: HTMLElement;
+  var json: any[];
+
+  function load(...files: string[]): any;
+  function load(file1: string, append?: boolean): any;
+  function load(file1: string, file2: string, append?: boolean): any;
+  function load(file1: string, file2: string, file3: string, append?: boolean): any;
+  function load(file1: string, file2: string, file3: string, file4: string, append?: boolean): any;
+  function load(file1: string, file2: string, file3: string, file4: string, file5: string, append?: boolean): any;
+
+  function set(...htmlStrs: string[]): HTMLElement|HTMLElement[];
+  function set(htmlStr1: string, append?: boolean): HTMLElement|HTMLElement[];
+  function set(htmlStr1: string, htmlStr2: string, append?: boolean): HTMLElement|HTMLElement[];
+  function set(htmlStr1: string, htmlStr2: string, htmlStr3: string, append?: boolean): HTMLElement|HTMLElement[];
+  function set(htmlStr1: string, htmlStr2: string, htmlStr3: string, htmlStr4: string, append?: boolean): HTMLElement|HTMLElement[];
+  function set(htmlStr1: string, htmlStr2: string, htmlStr3: string, htmlStr4: string, htmlStr5: string, append?: boolean): HTMLElement|HTMLElement[];
+
+  function cleanup(): void;
+
+  function setBase(fixtureBasePath: string): void;
+}

karma/karma.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path="../node/node.d.ts" />
 /// <reference path="../log4js/log4js.d.ts" />
 

kendo-ui/kendo-ui.d.ts

@@ -89,40 +89,10 @@ declare namespace kendo {
         };
     };
 
-    var cultures: {[culture: string] : {
-        name?: string;
-        calendar?: {
-            AM: string[];
-            PM: string[];
-            days: {
-                names: string[];
-                namesAbbr: string[];
-                namesShort: string[];
-                firstDay: number;
-            };
-            months: {
-                names: string[];
-                namesAbbr: string[];
-            };
-            patterns: {
-                D: string;
-                F: string;
-                G: string;
-                M: string;
-                T: string;
-                Y: string;
-                d: string;
-                g: string;
-                m: string;
-                s: string;
-                t: string;
-                u: string;
-                y: string;
-            };
-            twoDigitYearMax: number;
-        };
-        calendars?: {
-            standard: {
+    var cultures: {
+        [culture: string]: {
+            name?: string;
+            calendar?: {
                 AM: string[];
                 PM: string[];
                 days: {
@@ -152,25 +122,57 @@ declare namespace kendo {
                 };
                 twoDigitYearMax: number;
             };
-        };
-        numberFormat?: {
-            currency: {
+            calendars?: {
+                standard: {
+                    AM: string[];
+                    PM: string[];
+                    days: {
+                        names: string[];
+                        namesAbbr: string[];
+                        namesShort: string[];
+                        firstDay: number;
+                    };
+                    months: {
+                        names: string[];
+                        namesAbbr: string[];
+                    };
+                    patterns: {
+                        D: string;
+                        F: string;
+                        G: string;
+                        M: string;
+                        T: string;
+                        Y: string;
+                        d: string;
+                        g: string;
+                        m: string;
+                        s: string;
+                        t: string;
+                        u: string;
+                        y: string;
+                    };
+                    twoDigitYearMax: number;
+                };
+            };
+            numberFormat?: {
+                currency: {
+                    decimals: number;
+                    groupSize: number[];
+                    pattern: string[];
+                    symbol: string;
+                };
                 decimals: number;
                 groupSize: number[];
                 pattern: string[];
-                symbol: string;
+                percent: {
+                    decimals: number;
+                    groupSize: number[];
+                    pattern: string[];
+                    symbol: string;
+                };
             };
-            decimals: number;
-            groupSize: number[];
-            pattern: string[];
-            percent: {
-                decimals: number;
-                groupSize: number[];
-                pattern: string[];
-                symbol: string;
-            };
-        };
-    }};
+        }
+    };
 
     function format(format: string, ...values: any[]): string;
 
@@ -488,8 +490,8 @@ declare namespace kendo.data {
         change(e: Object): void;
         start(source: kendo.Observable): void;
         stop(source: kendo.Observable): void;
-        get (): any;
-        set (value: any): void;
+        get(): any;
+        set(value: any): void;
         destroy(): void;
     }
 
@@ -500,7 +502,7 @@ declare namespace kendo.data {
     }
 
     class EventBinding extends Binding {
-        get (): void;
+        get(): void;
     }
 
     class TemplateBinding extends Binding {
@@ -531,7 +533,7 @@ declare namespace kendo.data {
     interface BinderOptions {
     }
 
-    class ObservableObject extends Observable{
+    class ObservableObject extends Observable {
         constructor(value?: any);
         uid: string;
         init(value?: any): void;
@@ -571,6 +573,7 @@ declare namespace kendo.data {
         isAllDay?: boolean;
         id?: any;
         start?: Date;
+        taskId?: number;
         startTimezone?: string;
         recurrenceId?: any;
         recurrenceRule?: string;
@@ -583,7 +586,7 @@ declare namespace kendo.data {
         static fields: DataSourceSchemaModelFields;
 
         constructor(data?: SchedulerEventData);
-
+        taskId: number;
         description: string;
         end: Date;
         endTimezone: string;
@@ -2653,7 +2656,7 @@ declare namespace kendo.ui {
         separator?: string;
         suggest?: boolean;
         headerTemplate?: string|Function;
-        template?: string|Function;
+        template?: string | Function;
         valuePrimitive?: boolean;
         virtual?: boolean|AutoCompleteVirtual;
         change?(e: AutoCompleteChangeEvent): void;
@@ -4471,6 +4474,7 @@ declare namespace kendo.ui {
         width?: string|number;
         values?: any;
         menu?: boolean;
+        type?: any;
     }
 
     interface GridEditable {
@@ -5890,6 +5894,7 @@ declare namespace kendo.ui {
         destroy(): void;
         enable(enable: boolean): void;
         value(): any;
+        values(): any;
         value(selectionStart: number, selectionEnd: number): void;
         resize(): void;
 
@@ -8834,6 +8839,7 @@ declare namespace kendo.dataviz.ui {
         type?: string;
         visible?: boolean;
         weekStartDay?: number;
+        axisCrossingValues?: number[];
         notes?: ChartCategoryAxisItemNotes;
     }
 
@@ -10599,6 +10605,7 @@ declare namespace kendo.dataviz.ui {
         autoBind?: boolean;
         axisDefaults?: ChartAxisDefaults;
         categoryAxis?: ChartCategoryAxisItem[];
+        valueAxis?: ChartValueAxisItem[];
         chartArea?: ChartChartArea;
         dataSource?: any|any|kendo.data.DataSource;
         legend?: ChartLegend;
@@ -10614,7 +10621,6 @@ declare namespace kendo.dataviz.ui {
         title?: ChartTitle;
         tooltip?: ChartTooltip;
         transitions?: boolean;
-        valueAxis?: ChartValueAxisItem[];
         xAxis?: ChartXAxisItem[];
         yAxis?: ChartYAxisItem[];
         zoomable?: boolean|ChartZoomable;

knex/knex-tests.ts

@@ -380,6 +380,8 @@ knex.transaction(function(trx) {
 
 // Using trx as a transaction object:
 knex.transaction(function(trx) {
+  
+  trx.raw('')
 
   var info: any;
   var books: any[] = [

knex/knex.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: Qubo <https://github.com/tkQubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../bluebird/bluebird-2.0.d.ts" />
 /// <reference path="../node/node.d.ts" />
 
 declare module "knex" {
@@ -330,6 +330,7 @@ declare module "knex" {
     interface Transaction extends QueryBuilder {
       commit: any;
       rollback: any;
+      raw: Knex.RawBuilder;
     }
 
     //
@@ -370,6 +371,7 @@ declare module "knex" {
       enum(columnName: string, values: Value[]): ColumnBuilder;
       enu(columnName: string, values: Value[]): ColumnBuilder;
       json(columnName: string): ColumnBuilder;
+      jsonb(columnName: string): ColumnBuilder;
       uuid(columnName: string): ColumnBuilder;
       comment(val: string): TableBuilder;
       specificType(columnName: string, type: string): ColumnBuilder;

koa-hbs/koa-hbs-tests.ts

@@ -0,0 +1,21 @@
+/// <reference path="./koa-hbs.d.ts" />
+/// <reference path="../koa/koa.d.ts" />
+
+import * as Hbs from 'koa-hbs';
+import * as Koa from 'koa';
+import * as Path from 'path';
+
+const app = new Koa();
+const hbs = new Hbs();
+
+app.use(hbs.middleware({
+    viewPath: Path.join(__dirname, './views')
+}));
+
+app.use(function *(next: any) {
+    yield this.render('index', {
+        title: 'Hello World!'
+    });
+});
+
+app.listen(3000);

koa-hbs/koa-hbs.d.ts

@@ -0,0 +1,55 @@
+// Type definitions for koa-favicon v2.x
+// Project: https://github.com/gilt/koa-hbs
+// Definitions by: Jacob Malone <https://github.com/jcbmln/>
+// Definitions: https://github.com/jcbmln/DefinitelyTyped
+
+/* =================== USAGE ===================
+
+    import * as Hbs from "koa-hbs";
+    import * as Koa from "koa";
+
+    var hbs = new Hbs();
+    var app = new Koa();
+
+    app.use(hbs.middleware({
+        viewPath: __dirname + '/views'
+    }));
+
+    app.use(function *() {
+        yield this.render('main', {
+            title: 'koa-hbs'
+        });
+    });
+
+ =============================================== */
+
+/// <reference path="../koa/koa.d.ts" />
+
+declare module "koa-hbs" {
+
+    import * as Koa from "koa";
+
+    namespace Hbs {
+        export interface Middleware {
+            viewPath: Array<string> | string,
+            handlebars?: Function,
+            templateOptions?: {},
+            extname?: string,
+            partialsPath?: Array<string> | string,
+            defaultLayout?: string,
+            layoutsPath?: string,
+            contentHelperName?: string,
+            blockHelperName?: string,
+            disableCache?: boolean 
+        }
+    }
+
+    class Hbs {
+        constructor();
+
+        middleware(opts: Hbs.Middleware): any;
+    }
+
+    namespace Hbs {}
+    export = Hbs;
+}

koa-router/koa-router-tests.ts

@@ -11,6 +11,9 @@ const router = new Router({
 });
 
 router
+  .param('id', function(id, ctx, next) {
+    next();
+  })
   .get('/', function (ctx, next) {
     ctx.body = 'Hello World!';
   })
@@ -23,7 +26,7 @@ router
   .del('/users/:id', function (ctx, next) {
     // ...
   });
-  
+
 router.get('user', '/users/:id', function (ctx, next) {
     ctx.body = "sdsd";
 });

koa-router/koa-router.d.ts

@@ -30,7 +30,7 @@ declare module "koa-router" {
 
         export interface IRouterOptions {
             /**
-             * Router prefixes 
+             * Router prefixes
              */
             prefix?: string;
             /**
@@ -52,6 +52,10 @@ declare module "koa-router" {
             (ctx: Router.IRouterContext, next?: () => any): any;
         }
 
+        export interface IParamMiddleware {
+            (param: string, ctx: Router.IRouterContext, next?: () => any): any;
+        }
+
         export interface IRouterAllowedMethodsOptions {
             /**
              * throw error instead of setting status and header
@@ -141,13 +145,13 @@ declare module "koa-router" {
          */
         get(name: string, path: string, ...middleware: Array<Router.IMiddleware>): Router;
         get(path: string, ...middleware: Array<Router.IMiddleware>): Router;
-        
+
         /**
          * HTTP post method
          */
         post(name: string, path: string, ...middleware: Array<Router.IMiddleware>): Router;
         post(path: string, ...middleware: Array<Router.IMiddleware>): Router;
-        
+
         /**
          * HTTP put method
          */
@@ -214,7 +218,7 @@ declare module "koa-router" {
 
         /**
          * Redirect `source` to `destination` URL with optional 30x status `code`.
-         * 
+         *
          * Both `source` and `destination` can be route names.
          */
         redirect(source: string, destination: string, code?: number): Router;
@@ -245,7 +249,7 @@ declare module "koa-router" {
         /**
          * Run middleware for named route parameters. Useful for auto-loading or validation.
          */
-        param(param: string, middleware: Router.IMiddleware): Router;
+        param(param: string, middleware: Router.IParamMiddleware): Router;
 
         /**
          * Generate URL from url pattern and given `params`.

libxmljs/libxmljs-tests.ts

@@ -1,4 +1,4 @@
-/// <reference path="..\node\node.d.ts" />
+/// <reference path="../node/node.d.ts" />
 /// <reference path="libxmljs.d.ts" />
 
 var libxmljs = require("libxmljs");

lodash/lodash-3.10-tests.ts

@@ -9658,6 +9658,25 @@ namespace TestSnakeCase {
     }
 }
 
+// _.split
+namespace TestSplit {
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('a-b-c').split();
+        result = _('a-b-c').split('-');
+        result = _('a-b-c').split('-', 2);
+    }
+
+    {
+        let result: _.LoDashImplicitArrayWrapper<string>;
+
+        result = _('a-b-c').chain().split();
+        result = _('a-b-c').chain().split('-');
+        result = _('a-b-c').chain().split('-', 2);
+    }
+}
+
 // _.startCase
 namespace TestStartCase {
     {

lodash/lodash-3.10.d.ts

@@ -14720,6 +14720,27 @@ declare module _ {
         snakeCase(): LoDashExplicitWrapper<string>;
     }
 
+    //_.split
+    interface LoDashImplicitWrapper<T> {
+        /**
+         * Splits string by separator.
+         *
+         * Note: This method is based on String#split.
+         * 
+         * @param separator The separator pattern to split by.
+         * @param limit The length to truncate results to.
+         * @return Returns the new array with the terms splitted.
+         */
+        split(separator?: RegExp|string, limit?: number): LoDashImplicitArrayWrapper<string>;
+    }
+
+    interface LoDashExplicitWrapper<T> {
+        /**
+         * @see _.split
+         */
+        split(separator?: RegExp|string, limit?: number): LoDashImplicitArrayWrapper<string>;
+    }
+
     //_.startCase
     interface LoDashStatic {
         /**

lodash/lodash.d.ts

@@ -172,6 +172,7 @@ Other changes
 - [x] Ensured _.range preserves the sign of start of -0
 - [x] Ensured _.reduce & _.reduceRight use getIteratee in their array branch
 - [x] Fixed rounding issue with the precision param of _.floor
+- [x] Added flush method to debounced & throttled functions
 
 ** LATER **
 Misc:
@@ -185,7 +186,6 @@ Misc:
 - [ ] _.extend as an alias of _.assignIn
 - [ ] _.extendWith as an alias of _.assignInWith
 - [ ] Added clear method to _.memoize.Cache
-- [ ] Added flush method to debounced & throttled functions
 - [ ] Added support for ES6 maps, sets, & symbols to _.clone, _.isEqual, & _.toArray
 - [ ] Enabled _.flow & _.flowRight to accept an array of functions
 - [ ] Ensured “Collection” methods treat functions as objects
@@ -10132,9 +10132,9 @@ declare module _ {
         /**
          * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since
          * the last time the debounced function was invoked. The debounced function comes with a cancel method to
-         * cancel delayed invocations. Provide an options object to indicate that func should be invoked on the
-         * leading and/or trailing edge of the wait timeout. Subsequent calls to the debounced function return the
-         * result of the last func invocation.
+         * cancel delayed invocations and a flush method to immediately invoke them. Provide an options object to
+         * indicate that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent
+         * calls to the debounced function return the result of the last func invocation.
          *
          * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only
          * if the the debounced function is invoked more than once during the wait timeout.
@@ -10755,9 +10755,9 @@ declare module _ {
     interface LoDashStatic {
         /**
          * Creates a throttled function that only invokes func at most once per every wait milliseconds. The throttled
-         * function comes with a cancel method to cancel delayed invocations. Provide an options object to indicate
-         * that func should be invoked on the leading and/or trailing edge of the wait timeout. Subsequent calls to
-         * the throttled function return the result of the last func call.
+         * function comes with a cancel method to cancel delayed invocations and a flush method to immediately invoke
+         * them. Provide an options object to indicate that func should be invoked on the leading and/or trailing edge
+         * of the wait timeout. Subsequent calls to the throttled function return the result of the last func call.
          *
          * Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if
          * the the throttled function is invoked more than once during the wait timeout.
@@ -19159,6 +19159,7 @@ declare module _ {
 
     interface Cancelable {
         cancel(): void;
+        flush(): void;
     }
 }
 

lru-cache/lru-cache.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for lru-cache v2.5.0
+// Type definitions for lru-cache v4.0.1
 // Project: https://github.com/isaacs/node-lru-cache
 // Definitions by: Bart van der Schoor <https://github.com/Bartvds>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
@@ -12,20 +12,22 @@ declare module 'lru-cache' {
 			max?: number;
 			maxAge?: number;
 			length?: (value: T) => number;
-			dispose?: (key: string, value: T) => void;
+			dispose?: (key: any, value: T) => void;
 			stale?: boolean;
 		}
 
 		interface Cache<T> {
-			set(key: string, value: T): void;
-			get(key: string): T;
-			peek(key: string): T;
-			has(key: string): boolean
-			del(key: string): void;
+			set(key: any, value: T, maxAge?: number): void;
+			get(key: any): T;
+			peek(key: any): T;
+			has(key: any): boolean
+			del(key: any): void;
 			reset(): void;
-			forEach(iter: (value: T, key: string, cache: Cache<T>) => void, thisp?: any): void;
-
-			keys(): string[];
+			prune(): void;
+			forEach(iter: (value: T, key: any, cache: Cache<T>) => void, thisp?: any): void;
+			itemCount: number;
+			length: number
+			keys(): any[];
 			values(): T[];
 		}
 	}