Merge branch 'master' into feat/joi-14.0

notNeededPackages.json

@@ -930,6 +930,12 @@
             "sourceRepoURL": "https://github.com/blakeembrey/lower-case-first",
             "asOfVersion": "1.0.1"
         },
+        {
+            "libraryName": "mali",
+            "typingsPackageName": "mali",
+            "sourceRepoURL": "https://github.com/malijs/mali",
+            "asOfVersion": "0.9.2"
+        },
         {
             "libraryName": "maquette",
             "typingsPackageName": "maquette",
@@ -1200,6 +1206,12 @@
             "sourceRepoURL": "https://github.com/react-ga/react-ga",
             "asOfVersion": "2.3.0"
         },
+        {
+            "libraryName": "react-i18next",
+            "typingsPackageName": "react-i18next",
+            "sourceRepoURL": "https://github.com/i18next/react-i18next",
+            "asOfVersion": "8.1.0"
+        },
         {
             "libraryName": "react-monaco-editor",
             "typingsPackageName": "react-monaco-editor",

types/ajv-errors/index.d.ts

@@ -2,6 +2,7 @@
 // Project: https://github.com/epoberezkin/ajv-errors
 // Definitions by: Afshawn Lotfi <https://github.com/afshawnlotfi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 import { Ajv } from "ajv";
 

types/algoliasearch/algoliasearch-tests.ts

@@ -177,3 +177,31 @@ client.copyIndex('from', 'to', ()=> {})
 // with scope
 client.copyIndex('from', 'to', ['settings']).then(()=>{})
 client.copyIndex('from', 'to', ['synonyms', 'rules'], ()=> {})
+
+// Browsing
+const browser = index.browseAll();
+index.browseAll('query');
+index.browseAll('', {
+  filters: 'dog',
+});
+
+let hits: Object[] = [];
+
+browser.on('result', function onResult(content) {
+  hits = hits.concat(content.hits);
+});
+
+browser.on('end', function onEnd() {
+  const _message = `We got ${hits.length} hits`
+});
+
+browser.on('error', function onError(err) {
+  throw err;
+});
+
+browser.stop()
+
+index.browse("", {
+  advancedSyntax: false,
+  attributesToRetrieve: ['dogs']
+})

types/algoliasearch/index.d.ts

@@ -1,11 +1,13 @@
-// Type definitions for algoliasearch-client-js 3.27.0
+// Type definitions for algoliasearch-client-js 3.30.0
 // Project: https://github.com/algolia/algoliasearch-client-js
 // Definitions by: Baptiste Coquelle <https://github.com/cbaptiste>
 //                 Haroen Viaene <https://github.com/haroenv>
 //                 Aurélien Hervé <https://github.com/aherve>
 //                 Samuel Vaillant <https://github.com/samouss>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.8
+
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 
 declare namespace algoliasearch {
   /**
@@ -611,6 +613,11 @@ declare namespace algoliasearch {
       options: SearchForFacetValues.Parameters,
       cb: (err: Error, res: SearchForFacetValues.Response) => void
     ): void;
+    /**
+     * Browse an index
+     * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
+     */
+    browse(query: string, parameters: BrowseParameters, cb: (err: Error, res: BrowseResponse) => void): void;
     /**
      * Browse an index
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -620,7 +627,7 @@ declare namespace algoliasearch {
      * Browse an index
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
      */
-    browse(query: string): Promise<BrowseResponse>;
+    browse(query: string, parameters?: BrowseParameters): Promise<BrowseResponse>;
     /**
      * Browse an index from a cursor
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -638,7 +645,7 @@ declare namespace algoliasearch {
      * Browse an entire index
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
      */
-    browseAll(): Promise<Response>;
+    browseAll(query?: string, parameters?: BrowseParameters): Browser;
     /**
      * Clear an index content
      * https://github.com/algolia/algoliasearch-client-js#clear-index---clearindex
@@ -966,6 +973,22 @@ declare namespace algoliasearch {
     query: string;
     processingTimeMS: number;
   }
+  type BrowseParameters = Omit<
+    QueryParameters,
+    | "typoTolerance"
+    | "distinct"
+    | "facets"
+    | "getRankingInfo"
+    | "attributesToHighlight"
+    | "attributesToSnippet"
+  >
+  interface Browser {
+    on(type: "error", cb: (err: Error) => void): void
+    on(type: "end", cb: () => void): void
+    on(type: "stop", cb: () => void): void
+    on(type: "result", cb: (content: BrowseResponse) => void): void
+    stop(): void
+  }
   /**
    * Describes a synonym object
    */

types/algoliasearch/lite/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for algoliasearch-client-js 3.27.0
+// Type definitions for algoliasearch-client-js 3.30.0
 // Project: https://github.com/algolia/algoliasearch-client-js
 // Definitions by: Baptiste Coquelle <https://github.com/cbaptiste>
 //                 Haroen Viaene <https://github.com/haroenv>
@@ -6,7 +6,9 @@
 //                 Samuel Vaillant <https://github.com/samouss>
 //                 Claas Brüggemann <https://github.com/ClaasBrueggemann>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.8
+
+type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>
 
 declare namespace algoliasearch {
   /**
@@ -130,6 +132,11 @@ declare namespace algoliasearch {
       options: SearchForFacetValues.Parameters,
       cb: (err: Error, res: SearchForFacetValues.Response) => void
     ): void;
+    /**
+     * Browse an index
+     * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
+     */
+    browse(query: string, parameters: BrowseParameters, cb: (err: Error, res: BrowseResponse) => void): void;
     /**
      * Browse an index
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -139,7 +146,7 @@ declare namespace algoliasearch {
      * Browse an index
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
      */
-    browse(query: string): Promise<BrowseResponse>;
+    browse(query: string, parameters?: BrowseParameters): Promise<BrowseResponse>;
     /**
      * Browse an index from a cursor
      * https://github.com/algolia/algoliasearch-client-js#backup--export-an-index---browse
@@ -194,7 +201,15 @@ declare namespace algoliasearch {
     query: string;
     processingTimeMS: number;
   }
-
+  type BrowseParameters = Omit<
+    QueryParameters,
+    | "typoTolerance"
+    | "distinct"
+    | "facets"
+    | "getRankingInfo"
+    | "attributesToHighlight"
+    | "attributesToSnippet"
+  >
   interface QueryParameters {
     /**
      * Query string used to perform the search

types/amplitude-js/amplitude-js-tests.ts

@@ -1,85 +1,110 @@
 // Tests for Amplitude SDK TypeScript definitions
 
 module Amplitude.Tests {
+
     function all() {
-        amplitude.init('YOUR_API_KEY_HERE', null, {
-            // optional configuration options
+        var client: amplitude.AmplitudeClient = new amplitude.AmplitudeClient();
+        var identify: amplitude.Identify = new amplitude.Identify();
+        var revenue: amplitude.Revenue = new amplitude.Revenue();
+
+        client = amplitude.getInstance();
+        client = amplitude.getInstance('some name');
+
+        amplitude.__VERSION__ === '1.2.3';
+        amplitude.options.logLevel = 'WARN';
+
+        amplitude.init('API_KEY', 'USER_ID', {
             saveEvents: true,
             includeUtm: true,
             includeReferrer: true,
             batchEvents: true,
             eventUploadThreshold: 50
-        });
-        amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE', null, () => {});
+        }, function () { });
+        amplitude.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
+        amplitude.init('API_KEY', 'USER_ID');
+        amplitude.init('API_KEY');
 
-        amplitude.logEvent('EVENT_IDENTIFIER_HERE');
-        amplitude.setUserId('USER_ID_HERE');
-        amplitude.init('YOUR_API_KEY_HERE', 'USER_ID_HERE');
-        amplitude.setUserId(null); // not string 'null'
-        amplitude.setVersionName('VERSION_NAME_HERE');
-
-        amplitude.regenerateDeviceId();
-        amplitude.setDeviceId('CUSTOM_DEVICE_ID');
-
-        amplitude.logEvent('EVENT_IDENTIFIER_HERE', {
-            'color': 'blue',
-            'age': 20,
-            'key': 'value'
-        });
+        amplitude.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
+        amplitude.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
         amplitude.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
+        amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
+
+        amplitude.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
+        amplitude.setDomain('.amplitude.com');
+        amplitude.setGroup('orgId', '15');
+        amplitude.setGroup('orgId', ['15', '16']);
+        amplitude.setUserId('joe@gmail.com');
+        amplitude.setUserProperties({ 'gender': 'female', 'sign_up_complete': true })
+        amplitude.setVersionName('1.12.3');
+        amplitude.isNewSession();
+        amplitude.getSessionId() === 123;
 
-        let identify = new amplitude.Identify().set('gender', 'female').set('age', 20);
         amplitude.identify(identify);
+        amplitude.logRevenue(3.99, 1, 'product_1234');
+        amplitude.logRevenueV2(revenue);
 
-        identify = new amplitude.Identify().setOnce('sign_up_date', '08/24/2015');
-        amplitude.identify(identify);
 
-        identify = new amplitude.Identify().setOnce('sign_up_date', '09/14/2015');
-        amplitude.identify(identify);
+        client.init('API_KEY', 'USER_ID', {
+            saveEvents: true,
+            includeUtm: true,
+            includeReferrer: true,
+            batchEvents: true,
+            eventUploadThreshold: 50
+        }, function () { });
+        client.init('API_KEY', 'USER_ID', { includeReferrer: true, includeUtm: true });
+        client.init('API_KEY', 'USER_ID');
+        client.init('API_KEY');
 
-        identify = new amplitude.Identify().unset('gender').unset('age');
-        amplitude.identify(identify);
+        client.logEvent('Clicked Homepage Button', { 'finished_flow': false, 'clicks': 15 });
+        client.logEvent('EVENT_IDENTIFIER_HERE', { 'color': 'blue', 'age': 20, 'key': 'value' });
+        client.logEvent("EVENT_IDENTIFIER_HERE", null, (httpCode, response) => { });
+        client.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
+        client.logEventWithTimestamp('EVENT_IDENTIFIER_HERE', { 'key': 'value' }, 1505430378000, (httpCode, response) => { });
 
+
+        client.setDeviceId('45f0954f-eb79-4463-ac8a-233a6f45a8f0');
+        client.setDomain('.amplitude.com');
+        client.setUserId('joe@gmail.com');
+        client.setOptOut(true);
+        client.setGroup('type', 'name');
+        client.setGroup('type', ['name', 'name2']);
+        client.setUserProperties({ 'gender': 'female', 'sign_up_complete': true });
+        client.setGlobalUserProperties({ 'gender': 'female', 'sign_up_complete': true });
+        client.setVersionName('1.12.3');
+        client.setSessionId(1505430378000);
+
+        client.options.logLevel = 'WARN';
+        client.getSessionId() === 123;
+        client.isNewSession() === true;
+        client.regenerateDeviceId();
+        client.clearUserProperties();
+
+        client.identify(identify);
+        client.logRevenue(3.99, 1, 'product_1234');
+        client.logRevenueV2(revenue);
+
+
+        identify = new amplitude.Identify().set('colors', ['rose', 'gold']).add('karma', 1).setOnce('sign_up_date', '2016-03-31');
         identify = new amplitude.Identify().add('karma', 1).add('friends', 1);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify().append('ab-tests', 'new-user-test').append('some_list', [1, 2, 3, 4, 'values']);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify().prepend('ab-tests', 'new-user-test').prepend('some_list', [1, 2, 3, 4, 'values']);
-        amplitude.identify(identify);
-
-        identify = new amplitude.Identify()
-            .set('karma', 10)
-            .add('karma', 1)
-            .unset('karma');
-        amplitude.identify(identify);
-
+        identify = new amplitude.Identify().set('karma', 10).add('karma', 1).unset('karma');
+        identify = new amplitude.Identify().append('ab-tests', 'new-user-tests');
+        identify.append('some_list', [1, 2, 3, 4, 'values']);
+        identify = new amplitude.Identify().prepend('ab-tests', 'new-user-tests');
+        identify.prepend('some_list', [1, 2, 3, 4, 'values']);
+        identify = new amplitude.Identify().set('user_type', 'beta');
+        identify.set('name', { 'first': 'John', 'last': 'Doe' });
+        identify = new amplitude.Identify().setOnce('sign_up_date', '2016-04-01');
+        identify = new amplitude.Identify().unset('user_type').unset('age');
         identify = new amplitude.Identify()
             .set('colors', ['rose', 'gold'])
             .append('ab-tests', 'campaign_a')
             .append('existing_list', [4, 5]);
-        amplitude.identify(identify);
 
-        amplitude.setUserProperties({
-            gender: 'female',
-            age: 20
-        });
 
-        amplitude.clearUserProperties();
-
-        amplitude.setOptOut(true);
-        amplitude.setOptOut(false);
-
-        amplitude.setGroup('orgId', '15');
-        amplitude.setGroup('sport', ['soccer', 'tennis']);
-
-        // TODO: Implement those.
-        /*
-        var revenue = new amplitude.Revenue().setProductId('com.company.productId').setPrice(3.99).setQuantity(3);
-        amplitude.logRevenueV2(revenue);
-
-        amplitude.logEventWithGroups('initialize_game', { 'key': 'value' }, { 'sport': 'soccer' });
-        */
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99);
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setEventProperties({ 'city': 'San Francisco' });
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setQuantity(5);
+        revenue = new amplitude.Revenue().setProductId('productIdentifier').setPrice(10.99).setRevenueType('purchase');
     }
+
 }

types/amplitude-js/index.d.ts

@@ -1,61 +1,146 @@
-// Type definitions for Amplitude SDK 2.12.1
+// Type definitions for Amplitude SDK 4.4.0
 // Project: https://github.com/amplitude/Amplitude-Javascript
 // Definitions by: Arvydas Sidorenko <https://github.com/Asido>
-// Definitions: https://github.com/Asido/DefinitelyTyped
+//                 Dan Manastireanu <https://github.com/danmana>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 declare module amplitude {
+
+    type Callback = (responseCode: number, responseBody: string, details?: { reason: string; }) => void;
+    type LogReturn = number | void;
+
     interface Config {
+        apiEndpoint?: string;
         batchEvents?: boolean;
         cookieExpiration?: number;
         cookieName?: string;
+        userId?: string;
         deviceId?: string;
+        deviceIdFromUrlParam?: boolean;
         domain?: string;
         eventUploadPeriodMillis?: number;
         eventUploadThreshold?: number;
+        forceHttps?: boolean;
+        includeGclid?: boolean;
         includeReferrer?: boolean;
         includeUtm?: boolean;
         language?: string;
+        logLevel?: 'DISABLE' | 'ERROR' | 'WARN' | 'INFO';
         optOut?: boolean;
         platform?: string;
         saveEvents?: boolean;
         savedMaxCount?: number;
+        saveParamsReferrerOncePerSession?: boolean;
         sessionTimeout?: number;
+        trackingOptions?: {
+            city?: boolean;
+            country?: boolean;
+            device_model?: boolean;
+            dma?: boolean;
+            ip_address?: boolean;
+            language?: boolean;
+            os_name?: boolean;
+            os_version?: boolean;
+            platform?: boolean;
+            region?: boolean;
+            version_name?: boolean;
+        },
+        unsentKey?: string;
+        unsentIdentifyKey?: string;
         uploadBatchSize?: number;
     }
 
     export class Identify {
         set(key: string, value: any): Identify;
         setOnce(key: string, value: any): Identify;
-        add(key: string, value: number): Identify;
+        add(key: string, value: number | string): Identify;
         append(key: string, value: any): Identify;
         prepend(key: string, value: any): Identify;
 
         unset(key: string): Identify;
     }
 
-    export function init(apiKey: string): void;
-    export function init(apiKey: string, userId: string): void;
-    export function init(apiKey: string, userId: string, options: Config): void;
-    export function init(apiKey: string, userId: string, options: Config, callback: () => void): void;
+    export class Revenue {
+
+        setProductId(productId: string): Revenue;
+        setQuantity(quantity: number): Revenue;
+        setPrice(price: number): Revenue;
+        setRevenueType(revenueType: string): Revenue;
+        setEventProperties(eventProperties: any): Revenue;
+    }
+
+    export class AmplitudeClient {
+
+        constructor(instanceName?: string);
+
+        options: Config;
+
+        init(apiKey: string, userId?: string, config?: Config, callback?: (client: AmplitudeClient) => void): void;
+
+        setVersionName(versionName: string): void;
+
+        isNewSession(): boolean;
+        setSessionId(sessionId: number): void;
+        getSessionId(): number;
+
+        setDomain(domain: string): void;
+        setUserId(userId: string): void;
+
+        setDeviceId(id: string): void;
+        regenerateDeviceId(): void;
+
+        identify(identify_obj: Identify, opt_callback?: Callback): void;
+
+        setUserProperties(properties: any): void;
+        setGlobalUserProperties(properties: any): void;
+        clearUserProperties(): void;
+
+        setOptOut(enable: boolean): void;
+
+        setGroup(groupType: string, groupName: string | string[]): void;
+
+        logEvent(event: string, data?: any, callback?: Callback): LogReturn;
+        logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn;
+        logRevenueV2(revenue_obj: Revenue): LogReturn;
+        logRevenue(pric: number, quantity: number, product: string): LogReturn;
+        logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn;
+    }
+
+    // Proxy methods that get executed on the default AmplitudeClient instance (not all client methods are proxied)
+
+    export function init(apiKey: string, userId?: string, options?: Config, callback?: (client: AmplitudeClient) => void): void;
 
     export function setVersionName(version: string): void;
+
+    export function isNewSession(): boolean;
+    export function getSessionId(): number;
+
+    export function setDomain(domain: string): void;
+
     export function setUserId(userId: string): void;
 
     export function setDeviceId(id: string): void;
     export function regenerateDeviceId(): void;
 
-    export function identify(identify: Identify): void;
+    export function identify(identify: Identify, callback?: Callback): void;
 
-    export function setUserProperties(properties: Object): void;
+    export function setUserProperties(properties: any): void;
+    export function setGlobalUserProperties(properties: any): void;
     export function clearUserProperties(): void;
 
     export function setOptOut(optOut: boolean): void;
 
     export function setGroup(groupType: string, groupName: string | string[]): void;
 
-    export function logEvent(event: string): void;
-    export function logEvent(event: string, data: Object): void;
-    export function logEvent(event: string, data: Object, callback: (httpCode: number, response: any) => void): void;
+    export function logEvent(event: string, data?: any, callback?: Callback): LogReturn;
+    export function logEventWithGroups(event: string, data?: any, groups?: any, callback?: Callback): LogReturn;
+    export function logRevenueV2(revenue_obj: Revenue): LogReturn;
+    export function logRevenue(pric: number, quantity: number, product: string): LogReturn;
+    export function logEventWithTimestamp(event: string, data?: any, timestamp?: number, callback?: Callback): LogReturn;
 
+
+
+    export function getInstance(instanceName?: string): AmplitudeClient;
+    export const __VERSION__: string;
     export var options: Config;
 }

types/amqplib/index.d.ts

@@ -8,7 +8,7 @@
 
 import * as Promise from 'bluebird';
 import * as events from 'events';
-import { Replies, Options, Message } from './properties';
+import { Replies, Options, Message, GetMessage, ConsumeMessage } from './properties';
 export * from './properties';
 
 export interface Connection extends events.EventEmitter {
@@ -40,10 +40,10 @@ export interface Channel extends events.EventEmitter {
     publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): boolean;
     sendToQueue(queue: string, content: Buffer, options?: Options.Publish): boolean;
 
-    consume(queue: string, onMessage: (msg: Message | null) => any, options?: Options.Consume): Promise<Replies.Consume>;
+    consume(queue: string, onMessage: (msg: ConsumeMessage | null) => any, options?: Options.Consume): Promise<Replies.Consume>;
 
     cancel(consumerTag: string): Promise<Replies.Empty>;
-    get(queue: string, options?: Options.Get): Promise<Message | false>;
+    get(queue: string, options?: Options.Get): Promise<GetMessage | false>;
 
     ack(message: Message, allUpTo?: boolean): void;
     ackAll(): void;

types/amqplib/properties.d.ts

@@ -145,12 +145,32 @@ export interface Message {
     properties: MessageProperties;
 }
 
-export interface MessageFields {
+export interface GetMessage extends Message {
+    fields: GetMessageFields;
+}
+
+export interface ConsumeMessage extends Message {
+    fields: ConsumeMessageFields;
+}
+
+export interface CommonMessageFields {
     deliveryTag: number;
     redelivered: boolean;
     exchange: string;
     routingKey: string;
-    messageCount: string;
+}
+
+export interface MessageFields extends CommonMessageFields {
+    messageCount?: number;
+    consumerTag?: string;
+}
+
+export interface GetMessageFields extends CommonMessageFields {
+    messageCount: number;
+}
+
+export interface ConsumeMessageFields extends CommonMessageFields {
+    deliveryTag: number;
 }
 
 export interface MessageProperties {

types/angular-ui-sortable/angular-ui-sortable-tests.ts

@@ -16,6 +16,9 @@ interface SortLogInfo {
   Text: string;
 }
 
+// Ensure that the jQuery-ui defined `sortable()` method is not overwritten
+jQuery().sortable(); // $ExpectType JQuery<HTMLElement>
+
 myApp.controller('sortableController', function ($scope: MySortableControllerScope) {
   $scope.sortableOptions = {
     activate: function(e, ui) {
@@ -84,6 +87,7 @@ myApp.controller('sortableController', function ($scope: MySortableControllerSco
     update: function(e, ui) {
       var jQueryEventObject: JQueryEventObject = e;
       var uiSortableUIParams: ng.ui.UISortableUIParams<SortableModelInfo> = ui;
+      ui.item.sortable; // $ExpectType UISortableProperties<SortableModelInfo>
       var voidcanceled: void = ui.item.sortable.cancel();
       var isCanceled: Boolean = ui.item.sortable.isCanceled();
       var isCustomHelperUsed: Boolean =ui.item.sortable.isCustomHelperUsed();

types/angular-ui-sortable/index.d.ts

@@ -2,12 +2,16 @@
 // Project: https://github.com/angular-ui/ui-sortable
 // Definitions by: Thodoris Greasidis <https://github.com/thgreasi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.4
 
 /// <reference types="angular" />
+/// <reference types="jqueryui" />
 
 import * as ng from 'angular';
 
+// Diff / Omit taken from https://github.com/Microsoft/TypeScript/issues/12215#issuecomment-311923766
+type Omit<T, K extends keyof T> = Pick<T, ({ [P in keyof T]: P } & { [P in K]: never } & { [x: string]: never, [x: number]: never })[keyof T]>;
+
 declare module 'angular' {
     export namespace ui {
 
@@ -79,11 +83,11 @@ declare module 'angular' {
             isCustomHelperUsed(): Boolean;
         }
 
-        interface UISortableUIItem<T> extends ng.IAugmentedJQuery {
+        interface UISortableUIItem<T> extends Omit<ng.IAugmentedJQuery, 'sortable'> {
             sortable: UISortableProperties<T>;
         }
 
-        interface UISortableUIParams<T> extends SortableUIParams {
+        interface UISortableUIParams<T> extends Omit<SortableUIParams, 'item'> {
             item: UISortableUIItem<T>;
         }
 

types/ansi-styles/index.d.ts

@@ -3,7 +3,7 @@
 // Definitions by: bryn austin bellomy <https://github.com/brynbellomy>
 //                 plylrnsdy <https://github.com/plylrnsdy>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-
+// TypeScript Version: 2.1
 
 import { EscapeCode } from './escape-code';
 

types/apollo-upload-client/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/jaydenseric/apollo-upload-client#readme
 // Definitions by: Edward Sammut Alessi <https://github.com/Slessi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.2
+// TypeScript Version: 2.6
 
 import { ApolloLink } from "apollo-link";
 import { HttpOptions } from "apollo-link-http-common";

types/apollo-upload-client/tsconfig.json

@@ -2,7 +2,9 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6", "dom"
+            "es6",
+            "dom",
+            "esnext.asynciterable"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,

types/arangodb/index.d.ts

@@ -1698,7 +1698,7 @@ declare module "@arangodb/crypto" {
         key: string | null,
         token: string,
         noVerify?: boolean
-    ): string | null;
+    ): object | null;
     function md5(message: string): string;
     function sha1(message: string): string;
     function sha224(message: string): string;

types/astring/index.d.ts

@@ -0,0 +1,50 @@
+// Type definitions for astring 1.3
+// Project: https://github.com/davidbonnet/astring
+// Definitions by: Nikolaj Kappler <https://github.com/nkappler>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.8
+
+import * as ESTree from 'estree';
+import 'node';
+import { Stream } from 'stream';
+
+export interface Options {
+    /** string to use for indentation (defaults to "  ") */
+    indent?: string;
+    /** string to use for line endings (defaults to "\n") */
+    lineEnd?: string;
+    /** indent level to start from (defaults to 0) */
+    startingIndentLevel?: number;
+    /** generate comments if true (defaults to false) */
+    comments?: boolean;
+    /** custom code generator (defaults to astring.baseGenerator) */
+    generator?: object;
+    /** source map generator (defaults to null), see https://github.com/mozilla/source-map#sourcemapgenerator */
+    sourceMap?: any;
+}
+
+/** Returns a string representing the rendered code of the provided AST `node`. However, if an `output` stream is provided in the options, it writes to that stream and returns it. */
+export function generate(node: ESTree.Node, options?: Options): string;
+/** Returns a string representing the rendered code of the provided AST `node`. However, if an `output` stream is provided in the options, it writes to that stream and returns it. */
+export function generate(node: ESTree.Node, options: Options & {
+    /** output stream to write the rendered code to (defaults to null) */
+    output: Stream;
+}): Stream;
+
+/**
+ * A code generator consists of a mapping of node names and functions that take two arguments: `node` and `state`.
+ * The `node` points to the node from which to generate the code and the `state` exposes the `write` method that takes generated code strings.
+ */
+export type Generator = { [key in ESTree.Node["type"]]: (node: Extract<ESTree.Node, { type: key }>, state: { write(s: string): void }) => void };
+
+/** Base generator that can be used to extend Astring. See https://github.com/davidbonnet/astring#extending */
+export const baseGenerator: Generator;
+
+declare global {
+    interface astring {
+        generate: typeof generate;
+        /** Base generator that can be used to extend Astring. See https://github.com/davidbonnet/astring#extending */
+        baseGenerator: Generator;
+    }
+    const astring: astring;
+}

types/astring/test/astring-global.test.ts

@@ -0,0 +1,5 @@
+// global scope function
+astring.generate(null);
+
+// global scope function
+astring.baseGenerator.Program(null, { write(s: string) { return; } });

types/astring/test/astring.test.ts

@@ -0,0 +1,32 @@
+import { baseGenerator, generate } from "astring";
+import { FunctionExpression, MemberExpression, Program } from "estree";
+import { Stream } from "stream";
+
+const ast: Program = null;
+const functionE: FunctionExpression = null;
+const memberE: MemberExpression = null;
+
+// should accept different nodes
+generate(ast);
+generate(functionE);
+generate(memberE);
+
+// options without output option should generate string
+const string: string = generate(ast, {
+    comments: true,
+    generator: baseGenerator,
+    indent: "\t",
+    lineEnd: "\n",
+    startingIndentLevel: 42,
+    sourceMap: null
+});
+
+// options with output option should return Stream
+const stream: Stream = generate(ast, {
+    output: new Stream()
+});
+
+// Generator should map node types to functions whose first parameter is same node type
+baseGenerator.Program(ast, { write(s: string) { return; } });
+baseGenerator.FunctionExpression(functionE, { write(s: string) { return; } });
+baseGenerator.MemberExpression(memberE, { write(s: string) { return; } });

types/astring/tsconfig.json

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

types/astring/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}

types/async/index.d.ts

@@ -2,34 +2,34 @@
 // Project: https://github.com/caolan/async
 // Definitions by: Boris Yankov <https://github.com/borisyankov>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>, Angus Fenying <https://github.com/fenying>, Pascal Martin <https://github.com/pascalmartin>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 export as namespace async;
 
 export interface Dictionary<T> { [key: string]: T; }
 export type IterableCollection<T> = T[] | IterableIterator<T> | Dictionary<T>
 
-export interface ErrorCallback<T> { (err?: T): void; }
-export interface AsyncBooleanResultCallback<E> { (err?: E, truthValue?: boolean): void; }
-export interface AsyncResultCallback<T, E> { (err?: E, result?: T): void; }
-export interface AsyncResultArrayCallback<T, E> { (err?: E, results?: Array<T | undefined>): void; }
-export interface AsyncResultObjectCallback<T, E> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
+export interface ErrorCallback<E = Error> { (err?: E | null): void; }
+export interface AsyncBooleanResultCallback<E = Error> { (err?: E | null, truthValue?: boolean): void; }
+export interface AsyncResultCallback<T, E = Error> { (err?: E | null, result?: T): void; }
+export interface AsyncResultArrayCallback<T, E = Error> { (err?: E | null, results?: Array<T | undefined>): void; }
+export interface AsyncResultObjectCallback<T, E = Error> { (err: E | undefined, results: Dictionary<T | undefined>): void; }
 
-export interface AsyncFunction<T, E> { (callback: (err?: E, result?: T) => void): void; }
-export interface AsyncFunctionEx<T, E> { (callback: (err?: E, ...results: T[]) => void): void; }
-export interface AsyncIterator<T, E> { (item: T, callback: ErrorCallback<E>): void; }
-export interface AsyncForEachOfIterator<T, E> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
-export interface AsyncResultIterator<T, R, E> { (item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncMemoIterator<T, R, E> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
-export interface AsyncBooleanIterator<T, E> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
+export interface AsyncFunction<T, E = Error> { (callback: (err?: E | null, result?: T) => void): void; }
+export interface AsyncFunctionEx<T, E = Error> { (callback: (err?: E | null, ...results: T[]) => void): void; }
+export interface AsyncIterator<T, E = Error> { (item: T, callback: ErrorCallback<E>): void; }
+export interface AsyncForEachOfIterator<T, E = Error> { (item: T, key: number|string, callback: ErrorCallback<E>): void; }
+export interface AsyncResultIterator<T, R, E = Error> { (item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncMemoIterator<T, R, E = Error> { (memo: R | undefined, item: T, callback: AsyncResultCallback<R, E>): void; }
+export interface AsyncBooleanIterator<T, E = Error> { (item: T, callback: AsyncBooleanResultCallback<E>): void; }
 
-export interface AsyncWorker<T, E> { (task: T, callback: ErrorCallback<E>): void; }
-export interface AsyncVoidFunction<E> { (callback: ErrorCallback<E>): void; }
+export interface AsyncWorker<T, E = Error> { (task: T, callback: ErrorCallback<E>): void; }
+export interface AsyncVoidFunction<E = Error> { (callback: ErrorCallback<E>): void; }
 
 export type AsyncAutoTasks<R extends Dictionary<any>, E> = { [K in keyof R]: AsyncAutoTask<R[K], R, E> }
 export type AsyncAutoTask<R1, R extends Dictionary<any>, E> = AsyncAutoTaskFunctionWithoutDependencies<R1, E> | (keyof R | AsyncAutoTaskFunction<R1, R, E>)[];
-export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
-export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
+export interface AsyncAutoTaskFunctionWithoutDependencies<R1, E = Error> { (cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
+export interface AsyncAutoTaskFunction<R1, R extends Dictionary<any>, E = Error> { (results: R, cb: AsyncResultCallback<R1, E> | ErrorCallback<E>): void; }
 
 export interface AsyncQueue<T> {
     length(): number;
@@ -37,9 +37,8 @@ export interface AsyncQueue<T> {
     running(): number;
     idle(): boolean;
     concurrency: number;
-    push<E>(task: T | T[], callback?: ErrorCallback<E>): void;
-    push<R,E>(task: T, callback?: AsyncResultCallback<R, E>): void;
-    unshift<E>(task: T | T[], callback?: ErrorCallback<E>): void;
+    push<R,E = Error>(task: T | T[], callback?: AsyncResultCallback<R, E>): void;
+    unshift<E = Error>(task: T | T[], callback?: ErrorCallback<E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -61,7 +60,7 @@ export interface AsyncPriorityQueue<T> {
     concurrency: number;
     started: boolean;
     paused: boolean;
-    push<R,E>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
+    push<R,E = Error>(task: T | T[], priority: number, callback?: AsyncResultArrayCallback<R, E>): void;
     saturated: () => any;
     empty: () => any;
     drain: () => any;
@@ -94,112 +93,113 @@ export interface AsyncCargo {
 }
 
 // Collections
-export function each<T, E>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function each<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const eachSeries: typeof each;
-export function eachLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function eachLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const forEach: typeof each;
 export const forEachSeries: typeof each;
 export const forEachLimit: typeof eachLimit;
-export function forEachOf<T, E>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOf<T, E = Error>(obj: IterableCollection<T>, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const forEachOfSeries: typeof forEachOf;
-export function forEachOfLimit<T, E>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
+export function forEachOfLimit<T, E = Error>(obj: IterableCollection<T>, limit: number, iterator: AsyncForEachOfIterator<T, E>, callback?: ErrorCallback<E>): void;
 export const eachOf: typeof forEachOf;
 export const eachOfSeries: typeof forEachOf;
 export const eachOfLimit: typeof forEachOfLimit;
-export function map<T, R, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function map<T, R, E>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function map<T, R, E = Error>(arr: Dictionary<T>, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
 export const mapSeries: typeof map;
-export function mapLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function mapValuesLimit<T, R, E>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
-export function mapValues<T, R, E>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R, E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function mapValuesLimit<T, R, E = Error>(obj: Dictionary<T>, limit: number, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
+export function mapValues<T, R, E = Error>(obj: Dictionary<T>, iteratee: (value: T, key: string, callback: AsyncResultCallback<R, E>) => void, callback: AsyncResultObjectCallback<R, E>): void;
 export const mapValuesSeries: typeof mapValues;
-export function filter<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filter<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
 export const filterSeries: typeof filter;
-export function filterLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function filterLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultArrayCallback<T, E>): void;
 export const select: typeof filter;
 export const selectSeries: typeof filter;
 export const selectLimit: typeof filterLimit;
 export const reject: typeof filter;
 export const rejectSeries: typeof filter;
 export const rejectLimit: typeof filterLimit;
-export function reduce<T, R, E>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
+export function reduce<T, R, E = Error>(arr: T[] | IterableIterator<T>, memo: R, iterator: AsyncMemoIterator<T, R, E>, callback?: AsyncResultCallback<R, E>): void;
 export const inject: typeof reduce;
 export const foldl: typeof reduce;
 export const reduceRight: typeof reduce;
 export const foldr: typeof reduce;
-export function detect<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detect<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
 export const detectSeries: typeof detect;
-export function detectLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
+export function detectLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncResultCallback<T, E>): void;
 export const find: typeof detect;
 export const findSeries: typeof detect;
 export const findLimit: typeof detectLimit;
-export function sortBy<T, V, E>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function some<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function sortBy<T, V, E = Error>(arr: T[] | IterableIterator<T>, iterator: AsyncResultIterator<T, V, E>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function some<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const someSeries: typeof some;
-export function someLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function someLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const any: typeof some;
 export const anySeries: typeof someSeries;
 export const anyLimit: typeof someLimit;
-export function every<T, E>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function every<T, E = Error>(arr: IterableCollection<T>, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const everySeries: typeof every;
-export function everyLimit<T, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
+export function everyLimit<T, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncBooleanIterator<T, E>, callback?: AsyncBooleanResultCallback<E>): void;
 export const all: typeof every;
 export const allSeries: typeof every;
 export const allLimit: typeof everyLimit;
 
-export function concat<T, R, E>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
-export function concatLimit<T, R, E>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concat<T, R, E = Error>(arr: IterableCollection<T>, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
+export function concatLimit<T, R, E = Error>(arr: IterableCollection<T>, limit: number, iterator: AsyncResultIterator<T, R[], E>, callback?: AsyncResultArrayCallback<R, E>): void;
 export const concatSeries: typeof concat;
 
 // Control Flow
-export function series<T, E>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
-export function series<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallel<T, E>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallel<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
-export function parallelLimit<T, E>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
-export function parallelLimit<T, E>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
-export function whilst<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doWhilst<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function until<E>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doUntil<T, E>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
-export function during<E>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
-export function doDuring<E>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
-export function forever<E>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
-export function waterfall<T, E>(tasks: Function[], callback?: AsyncResultCallback<T, E | Error>): void;
+export function series<T, E = Error>(tasks: AsyncFunction<T, E>[], callback?: AsyncResultArrayCallback<T, E>): void;
+export function series<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, callback?: AsyncResultArrayCallback<T, E>): void;
+export function parallel<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, callback?: AsyncResultObjectCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Array<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultArrayCallback<T, E>): void;
+export function parallelLimit<T, E = Error>(tasks: Dictionary<AsyncFunction<T, E>>, limit: number, callback?: AsyncResultObjectCallback<T, E>): void;
+export function whilst<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doWhilst<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
+export function until<E = Error>(test: () => boolean, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doUntil<T, E = Error>(fn: AsyncFunctionEx<T, E>, test: (...results: T[]) => boolean, callback: ErrorCallback<E>): void;
+export function during<E = Error>(test: (testCallback : AsyncBooleanResultCallback<E>) => void, fn: AsyncVoidFunction<E>, callback: ErrorCallback<E>): void;
+export function doDuring<E = Error>(fn: AsyncVoidFunction<E>, test: (testCallback: AsyncBooleanResultCallback<E>) => void, callback: ErrorCallback<E>): void;
+export function forever<E = Error>(next: (next : ErrorCallback<E>) => void, errBack: ErrorCallback<E>) : void;
+export function waterfall<T, E = Error>(tasks: Function[], callback?: AsyncResultCallback<T, E>): void;
 export function compose(...fns: Function[]): Function;
 export function seq(...fns: Function[]): Function;
 export function applyEach(fns: Function[], ...argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
 export function applyEachSeries(fns: Function[], ...argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-export function queue<T, E>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
-export function queue<T, R, E>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
-export function priorityQueue<T, E>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
-export function cargo<E>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
-export function auto<R extends Dictionary<any>, E>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
-export function autoInject<E>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
-export function retry<T, E>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-export function retry<T, E>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E | Error>): void;
-export function retryable<T, E>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E | Error>;
-export function apply<E>(fn: Function, ...args: any[]): AsyncFunction<any,E | Error>;
+export function queue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency?: number): AsyncQueue<T>;
+export function queue<T, R, E = Error>(worker: AsyncResultIterator<T, R, E>, concurrency?: number): AsyncQueue<T>;
+export function priorityQueue<T, E = Error>(worker: AsyncWorker<T, E>, concurrency: number): AsyncPriorityQueue<T>;
+export function cargo<E = Error>(worker : (tasks: any[], callback : ErrorCallback<E>) => void, payload? : number) : AsyncCargo;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, concurrency?: number, callback?: AsyncResultCallback<R, E>): void;
+export function auto<R extends Dictionary<any>, E = Error>(tasks: AsyncAutoTasks<R, E>, callback?: AsyncResultCallback<R, E>): void;
+export function autoInject<E = Error>(tasks: any, callback?: AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: number, task: (callback : AsyncResultCallback<T, E>, results: any) => void, callback:  AsyncResultCallback<any, E>): void;
+export function retry<T, E = Error>(opts: { times: number, interval: number|((retryCount: number) => number) }, task: (callback: AsyncResultCallback<T, E>, results : any) => void, callback:  AsyncResultCallback<any, E>): void;
+export function retryable<T, E = Error>(opts: number | {times: number, interval: number}, task: AsyncFunction<T, E>): AsyncFunction<T, E>;
+export function apply<E = Error>(fn: Function, ...args: any[]): AsyncFunction<any,E>;
 export function nextTick(callback: Function, ...args: any[]): void;
 export const setImmediate: typeof nextTick;
 
-export function reflect<T, E>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
-export function reflectAll<T, E>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
+export function reflect<T, E = Error>(fn: AsyncFunction<T, E>) : (callback: (err: null, result: {error?: E, value?: T}) => void) => void;
+export function reflectAll<T, E = Error>(tasks: AsyncFunction<T, E>[]): ((callback: (err: null, result: {error?: E, value?: T}) => void) => void)[];
 
-export function timeout<T, E>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E | Error>;
-export function timeout<T, R, E>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E | Error>;
+export function timeout<T, E = Error>(fn: AsyncFunction<T, E>, milliseconds: number, info?: any): AsyncFunction<T, E>;
+export function timeout<T, R, E = Error>(fn: AsyncResultIterator<T, R, E>, milliseconds: number, info?: any): AsyncResultIterator<T, R, E>;
 
 export function times<T, E> (n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesSeries<T, E>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
-export function timesLimit<T, E>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesSeries<T, E = Error>(n: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
+export function timesLimit<T, E = Error>(n: number, limit: number, iterator: AsyncResultIterator<number, T, E>, callback: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
-export function transform<T, R, E>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: T[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: T[], acc: R[], iteratee: (acc: R[], item: T, key: number, callback: (error?: E) => void) => void, callback?: AsyncResultArrayCallback<T, E>): void;
 
-export function transform<T, R, E>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
-export function transform<T, R, E>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string] : T}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
+export function transform<T, R, E = Error>(arr: {[key: string] : T}, acc: {[key: string] : R}, iteratee: (acc: {[key: string] : R}, item: T, key: string, callback: (error?: E) => void) => void, callback?: AsyncResultObjectCallback<T, E>): void;
 
-export function race<T, E>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E | Error>) : void;
+export function race<T, E = Error>(tasks: (AsyncFunction<T, E>)[], callback: AsyncResultCallback<T, E>) : void;
 
 // Utils
 export function memoize(fn: Function, hasher?: Function): Function;

types/async/test/index.ts

@@ -114,7 +114,7 @@ async.series([
 ],
 function (err, results) { });
 
-async.series<string,Error>([
+async.series<string>([
     function (callback) {
         callback(undefined, 'one');
     },
@@ -138,7 +138,7 @@ async.series({
 },
 function (err, results) { });
 
-async.series<number,Error>({
+async.series<number>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -178,7 +178,7 @@ async.parallel([
 ],
 function (err, results) { });
 
-async.parallel<string,Error>([
+async.parallel<string>([
     function (callback) {
         setTimeout(function () {
             callback(undefined, 'one');
@@ -207,7 +207,7 @@ async.parallel({
 },
 function (err, results) { });
 
-async.parallel<number,Error>({
+async.parallel<number>({
     one: function (callback) {
         setTimeout(function () {
             callback(undefined, 1);
@@ -273,7 +273,7 @@ async.waterfall([
 ], function (err, result) { });
 
 
-var q = async.queue<any,Error>(function (task: any, callback: (err?:Error,msg?:string) => void) {
+var q = async.queue<any>(function (task: any, callback: (err?:Error,msg?:string) => void) {
     console.log('hello ' + task.name);
     callback(undefined,'a message.');
 }, 2);
@@ -293,7 +293,7 @@ q.push([{ name: 'baz' }, { name: 'bay' }, { name: 'bax' }], function (err) {
     console.log('finished processing bar');
 });
 
-q.push<string,Error>({name: 'foo'}, function (err,msg) {
+q.push<string>({name: 'foo'}, function (err, msg) {
   console.log('foo finished with a message "'+ msg! + '"');
 });
 
@@ -330,7 +330,7 @@ q.resume();
 q.kill();
 
 // tests for strongly typed tasks
-var q2 = async.queue<string,Error>(function (task: string, callback: () => void) {
+var q2 = async.queue<string>(function (task: string, callback: () => void) {
     console.log('Task: ' + task);
     callback();
 }, 1);
@@ -356,7 +356,7 @@ q2.unshift(['task3', 'task4', 'task5'], function (error) {
 });
 
 
-var aq = async.queue<number, number, Error>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
+var aq = async.queue<number, number>(function (level: number, callback: (error?: Error, newLevel?: number) => void) {
     console.log('hello ' + level);
     callback(undefined, level+1);
 });
@@ -387,14 +387,47 @@ cargo.push({ name: 'baz' }, function (err: Error) {
 
 var filename = '';
 async.auto({
-    get_data: function (callback: any) { },
-    make_folder: function (callback: any) { },
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
     //arrays with different types are not accepted by TypeScript.
-    write_file: ['get_data', 'make_folder', <any>function (callback: any) {
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
         callback(null, filename);
     }],
     //arrays with different types are not accepted by TypeScript.
-    email_link: ['write_file', <any>function (callback: any, results: any) { }]
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+});
+
+async.auto({
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
+    //arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
+        callback(null, filename);
+    }],
+    //arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+}, function (err, results) {
+    console.log('finished auto');
+});
+
+interface A {
+    get_data: any;
+    make_folder: any;
+    write_file: any;
+    email_link: any;
+}
+
+async.auto<A>({
+    get_data: function (callback: AsyncResultCallback<any>) { },
+    make_folder: function (callback: AsyncResultCallback<any>) { },
+    //arrays with different types are not accepted by TypeScript.
+    write_file: ['get_data', 'make_folder', <any>function (callback: AsyncResultCallback<any>) {
+        callback(null, filename);
+    }],
+    //arrays with different types are not accepted by TypeScript.
+    email_link: ['write_file', <any>function (callback: AsyncResultCallback<any>, results: any) { }]
+}, 1, function (err, results) {
+    console.log('finished auto');
 });
 
 async.retry(3, function (callback, results) { }, function (err, result) { });
@@ -459,10 +492,10 @@ async.dir(function (name: string, callback: any) {
 
 // each
 
-async.each<number,Error>({
+async.each<number>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -478,10 +511,10 @@ async.each<number,Error>({
 
 });
 
-async.eachSeries<number, Error>({
+async.eachSeries<number>({
     "a": 1,
     "b": 2
-}, function(val: number, next: ErrorCallback<Error>): void {
+}, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -497,14 +530,14 @@ async.eachSeries<number, Error>({
 
 });
 
-async.eachLimit<number, Error>({
+async.eachLimit<number>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: ErrorCallback<Error>): void {
+}, 2, function(val: number, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -522,10 +555,10 @@ async.eachLimit<number, Error>({
 
 // forEachOf/eachOf
 
-async.eachOf<number, Error>({
+async.eachOf<number>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -541,10 +574,10 @@ async.eachOf<number, Error>({
 
 });
 
-async.forEachOfSeries<number, Error>({
+async.forEachOfSeries<number>({
     "a": 1,
     "b": 2
-}, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -560,14 +593,14 @@ async.forEachOfSeries<number, Error>({
 
 });
 
-async.forEachOfLimit<number, Error>({
+async.forEachOfLimit<number>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, key: string, next: ErrorCallback<Error>): void {
+}, 2, function(val: number, key: string, next: ErrorCallback): void {
 
     setTimeout(function(): void {
 
@@ -585,11 +618,11 @@ async.forEachOfLimit<number, Error>({
 
 // map
 
-async.map<number, string, Error>({
+async.map<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -605,11 +638,11 @@ async.map<number, string, Error>({
 
 });
 
-async.mapSeries<number, string, Error>({
+async.mapSeries<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -625,14 +658,14 @@ async.mapSeries<number, string, Error>({
 
 });
 
-async.mapLimit<number, string, Error>({
+async.mapLimit<number, string>({
     "a": 1,
     "b": 2,
     "c": 3,
     "d": 4,
     "e": 5,
     "f": 6
-}, 2, function(val: number, next: AsyncResultCallback<string, Error>): void {
+}, 2, function(val: number, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -650,11 +683,11 @@ async.mapLimit<number, string, Error>({
 
 // mapValues
 
-async.mapValues<number, string, Error>({
+async.mapValues<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -670,11 +703,11 @@ async.mapValues<number, string, Error>({
 
 });
 
-async.mapValuesSeries<number, string, Error>({
+async.mapValuesSeries<number, string>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, key: string, next: AsyncResultCallback<string, Error>): void {
+}, function(val: number, key: string, next: AsyncResultCallback<string>): void {
 
     setTimeout(function(): void {
 
@@ -692,11 +725,11 @@ async.mapValuesSeries<number, string, Error>({
 
 // filter/select/reject
 
-async.filter<number, Error>({
+async.filter<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(val: number, next: AsyncBooleanResultCallback): void {
 
     setTimeout(function(): void {
 
@@ -712,11 +745,11 @@ async.filter<number, Error>({
 
 });
 
-async.reject<number, Error>({
+async.reject<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(val: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(val: number, next: AsyncBooleanResultCallback): void {
 
     setTimeout(function(): void {
 
@@ -734,11 +767,11 @@ async.reject<number, Error>({
 
 // concat
 
-async.concat<string, string, Error>({
+async.concat<string, string>({
     "a": "1",
     "b": "2",
     "c": "3"
-}, function(item: string, next: AsyncResultCallback<string[], Error>): void {
+}, function(item: string, next: AsyncResultCallback<string[]>): void {
 
     console.log(`async.concat: ${item}`);
 
@@ -752,11 +785,11 @@ async.concat<string, string, Error>({
 
 // detect/find
 
-async.detect<number, Error>({
+async.detect<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.detect/find: ${item}`);
 
@@ -777,11 +810,11 @@ async.detect<number, Error>({
 
 // every/all
 
-async.every<number,Error>({
+async.every<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.every/all: ${item}`);
 
@@ -795,11 +828,11 @@ async.every<number,Error>({
 
 // some/any
 
-async.some<number, Error>({
+async.some<number>({
     "a": 1,
     "b": 2,
     "c": 3
-}, function(item: number, next: AsyncBooleanResultCallback<Error>): void {
+}, function(item: number, next: AsyncBooleanResultCallback): void {
 
     console.log(`async.some/any: ${item}`);
 

types/atlassian-crowd-client/lib/models/session.d.ts

@@ -3,7 +3,7 @@ declare class Session {
     readonly token: string;
     readonly createdAt: Date;
     readonly expiresAt: Date;
- 
+
     constructor(token: string, createdAt: Date, expiresAt: Date);
     toCrowd(): SessionObj;
     static fromCrowd(obj: SessionObj): Session;

types/atlassian-crowd-client/settings.d.ts

@@ -3,7 +3,7 @@ export interface Settings {
     readonly application: {
         readonly name: string;
         readonly password: string;
-    }
+    };
     readonly nesting?: boolean;
     readonly sessionTimeout?: number;
     readonly debug?: boolean;

types/auth-header/auth-header-tests.ts

@@ -0,0 +1,6 @@
+import * as auth from 'auth-header';
+
+const basic: string = auth.format('Basic');
+const basic2: string = auth.format({scheme: 'Basic'});
+
+const parsed: {scheme: string, token: null | string | string[]} = auth.parse('');

types/auth-header/index.d.ts

@@ -0,0 +1,27 @@
+// Type definitions for auth-header 1.0
+// Project: https://github.com/izaakschroeder/auth-header
+// Definitions by: ForbesLindesay <https://github.com/ForbesLindesay>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+type Params =
+    | Array<[string, string | ReadonlyArray<string>]>
+    | {[key: string]: string | ReadonlyArray<string>};
+export {Params};
+
+export interface TokenOptions {
+    scheme: string;
+    token?: string;
+    params?: Params;
+}
+
+export interface Token {
+    scheme: string;
+    params: {[key: string]: string | string[]};
+    token: null | string | string[];
+}
+
+export function format(token: TokenOptions): string;
+export function format(scheme: string, token?: string, params?: Params): string;
+
+export function parse(header: string): Token;

types/auth-header/tsconfig.json

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

types/aws-lambda/aws-lambda-tests.ts

@@ -383,6 +383,8 @@ cognitoUserPoolEvent.triggerSource === "TokenGeneration_Authentication";
 cognitoUserPoolEvent.triggerSource === "TokenGeneration_NewPasswordChallenge";
 cognitoUserPoolEvent.triggerSource === "TokenGeneration_AuthenticateDevice";
 cognitoUserPoolEvent.triggerSource === "TokenGeneration_RefreshTokens";
+cognitoUserPoolEvent.triggerSource === "UserMigration_Authentication";
+cognitoUserPoolEvent.triggerSource === "UserMigration_ForgotPassword";
 str = cognitoUserPoolEvent.region;
 str = cognitoUserPoolEvent.userPoolId;
 strOrUndefined = cognitoUserPoolEvent.userName;
@@ -404,6 +406,7 @@ strOrUndefined = cognitoUserPoolEvent.request.session![0].challengeMetadata;
 strOrUndefined = cognitoUserPoolEvent.request.challengeName;
 str = cognitoUserPoolEvent.request.privateChallengeParameters!["answer"];
 str = cognitoUserPoolEvent.request.challengeAnswer!;
+strOrUndefined = cognitoUserPoolEvent.request.password;
 boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect;
 strOrUndefined = cognitoUserPoolEvent.response.smsMessage;
 strOrUndefined = cognitoUserPoolEvent.response.emailMessage;
@@ -415,6 +418,14 @@ str = cognitoUserPoolEvent.response.publicChallengeParameters!["captchaUrl"];
 str = cognitoUserPoolEvent.response.privateChallengeParameters!["answer"];
 strOrUndefined = cognitoUserPoolEvent.response.challengeMetadata;
 boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect;
+str = cognitoUserPoolEvent.response.userAttributes!["username"];
+cognitoUserPoolEvent.response.finalUserStatus === "CONFIRMED";
+cognitoUserPoolEvent.response.finalUserStatus === "RESET_REQUIRED";
+cognitoUserPoolEvent.response.messageAction === "SUPPRESS";
+cognitoUserPoolEvent.response.desiredDeliveryMediums === ["EMAIL"];
+cognitoUserPoolEvent.response.desiredDeliveryMediums === ["SMS"];
+cognitoUserPoolEvent.response.desiredDeliveryMediums === ["SMS", "EMAIL"];
+boolOrUndefined = cognitoUserPoolEvent.response.forceAliasCreation;
 
 // CloudFormation Custom Resource
 switch (cloudformationCustomResourceEvent.RequestType) {

types/aws-lambda/index.d.ts

@@ -22,6 +22,7 @@
 //                 Louis Larry <https://github.com/louislarry>
 //                 Daniel Papukchiev <https://github.com/dpapukchiev>
 //                 Oliver Hookins <https://github.com/ohookins>
+//                 James Gregory <https://github.com/jagregory>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -234,7 +235,9 @@ export interface CognitoUserPoolTriggerEvent {
     | "TokenGeneration_Authentication"
     | "TokenGeneration_NewPasswordChallenge"
     | "TokenGeneration_AuthenticateDevice"
-    | "TokenGeneration_RefreshTokens";
+    | "TokenGeneration_RefreshTokens"
+    | "UserMigration_Authentication"
+    | "UserMigration_ForgotPassword";
     region: string;
     userPoolId: string;
     userName?: string;
@@ -256,6 +259,7 @@ export interface CognitoUserPoolTriggerEvent {
         challengeName?: string;
         privateChallengeParameters?: { [key: string]: string };
         challengeAnswer?: string;
+        password?: string;
     };
     response: {
         autoConfirmUser?: boolean;
@@ -269,6 +273,11 @@ export interface CognitoUserPoolTriggerEvent {
         privateChallengeParameters?: { [key: string]: string };
         challengeMetadata?: string;
         answerCorrect?: boolean;
+        userAttributes?: { [key: string]: string };
+        finalUserStatus?: "CONFIRMED" | "RESET_REQUIRED";
+        messageAction?: "SUPPRESS";
+        desiredDeliveryMediums?: Array<"EMAIL" | "SMS">;
+        forceAliasCreation?: boolean;
     };
 }
 export type CognitoUserPoolEvent = CognitoUserPoolTriggerEvent;

types/axe-webdriverjs/tsconfig.json

@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,

types/axios-token-interceptor/index.d.ts

@@ -2,6 +2,7 @@
 // Project: https://github.com/sandrinodimattia/axios-token-interceptor#readme
 // Definitions by: Mike Dodge <https://github.com/innovation-team>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
 import { AxiosRequestConfig } from 'axios';
 

types/baidumap-web-sdk/tslint.json

@@ -2,14 +2,21 @@
     "extends": "dtslint/dt.json",
     "rules": {
         // All are TODOs
-        "eofline": false,
+        "adjacent-overload-signatures": false,
+        "array-type": false,
+        "ban-types": false,
         "comment-format": false,
         "dt-header": false,
+        "eofline": false,
         "max-line-length": false,
         "member-access": false,
+        "no-consecutive-blank-lines": false,
+        "no-empty-interface": false,
         "no-namespace": false,
+        "no-unnecessary-class": false,
         "no-useless-files": false,
         "no-var": false,
-        "semicolon": false
+        "semicolon": false,
+        "space-before-function-paren": false
     }
 }

types/basicauth-middleware/basicauth-middleware-tests.ts

@@ -0,0 +1,21 @@
+import express = require('express');
+import basicAuth = require('basicauth-middleware');
+
+const app = express();
+
+app.use(basicAuth("username", "password", "realm"));
+app.use(basicAuth([["username", "password"]]));
+
+function checkSync(username: string, password: string): boolean {
+  return username === "user" && password === "pass";
+}
+function checkCallback(username: string, password: string, callback: (err: Error|null, authorized: boolean) => void): void {
+  callback(null, username === "user" && password === "pass");
+}
+function checkPromise(username: string, password: string): Promise<boolean> {
+  return Promise.resolve(true);
+}
+
+app.use(basicAuth(checkSync));
+app.use(basicAuth(checkCallback));
+app.use(basicAuth(checkPromise));

types/basicauth-middleware/index.d.ts

@@ -0,0 +1,16 @@
+// Type definitions for basicauth-middleware 3.1
+// Project: https://github.com/nchaulet/basicauth-middleware
+// Definitions by: My Self <https://github.com/nchaulet>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
+
+import { RequestHandler } from "express";
+type checkFunctionSync = (username: string, password: string) => boolean;
+type checkFunctionCallback = (username: string, password: string, callback: (err: Error|null, authorized: boolean) => void) => void;
+type checkFunctionPromise = (username: string, password: string) => PromiseLike<boolean>;
+type CheckFunction = checkFunctionSync | checkFunctionPromise | checkFunctionCallback;
+
+declare function basicAuth(checkFnOrUsers: Array<[string, string]>|CheckFunction, realm?: string): RequestHandler;
+declare function basicAuth(username: string, password: string, realm?: string): RequestHandler;
+
+export = basicAuth;

types/basicauth-middleware/tsconfig.json

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

types/bell/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/hapijs/bell
 // Definitions by: Simon Schick <https://github.com/SimonSchick>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.7
+// TypeScript Version: 2.8
 
 import { Server, Request, Plugin, AuthCredentials } from 'hapi';
 

types/better-scroll/index.d.ts

@@ -1,6 +1,7 @@
 // Type definitions for better-scroll 1.12
 // Project: https://github.com/ustbhuangyi/better-scroll
 // Definitions by: cloudstone <https://github.com/stoneChen>
+//                 jack <https://github.com/cnjack>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 // TypeScript Version: 2.2
@@ -42,6 +43,24 @@ export interface PullUpOption {
     threshold: number;
 }
 
+export interface MouseWheelOption {
+  speed: number;
+  invert: boolean;
+  easeTime: number;
+}
+
+export interface ZoomOption {
+  start: number;
+  min: number;
+  max: number;
+}
+
+export interface InfinityOption {
+  fetch: (count: number) => void;
+  render: (item: any, div: Element) => Element;
+  createTombstone: () => Element;
+}
+
 export interface BounceObjectOption {
     top?: boolean;
     bottom?: boolean;
@@ -49,6 +68,10 @@ export interface BounceObjectOption {
     right?: boolean;
 }
 
+export interface DoubleClick {
+  delay: number;
+}
+
 export interface EaseOption {
     swipe?: {
         style: string;
@@ -73,6 +96,7 @@ export interface BsOption {
     directionLockThreshold: number;
     eventPassthrough: string | boolean;
     click: boolean;
+    dblclick: boolean | DoubleClick;
     tap: boolean;
     bounce: boolean | BounceObjectOption;
     bounceTime: number;
@@ -140,6 +164,23 @@ export interface BsOption {
      * }
      */
     pullUpLoad: Partial<PullUpOption> | boolean;
+
+    // mouseWheel: {
+    //  speed: 20,
+    //  invert: false,
+    //  easeTime: 300
+    // }
+    mouseWheel: Partial<MouseWheelOption> | boolean;
+
+    // zoom: {
+    //  start: 1,
+    //  min: 1,
+    //  max: 4
+    // }
+    zoom: Partial<ZoomOption> | boolean;
+
+    // https://ustbhuangyi.github.io/better-scroll/doc/zh-hans/options-advanced.html
+    infinity: Partial<InfinityOption> | boolean;
 }
 
 export interface Position {

types/bn.js/index.d.ts

@@ -45,7 +45,7 @@ interface ReductionContext {
 declare class BN {
     constructor(
         number: number | string | number[] | Buffer | BN,
-        base?: number,
+        base?: number | 'hex',
         endian?: Endianness
     );
     constructor(

types/boom/boom-tests.ts

@@ -144,12 +144,12 @@ const boomifiedError = Boom.boomify(new Error('test'), { statusCode: 400, messag
 
 // isBoom
 
-const isBoomError = new Boom('test')
+const isBoomError = new Boom('test');
 
 Boom.isBoom(isBoomError);
 
-const maybeBoom = <any>new Boom('test');
-if(Boom.isBoom(maybeBoom)) {
+const maybeBoom = <any> new Boom('test');
+if (Boom.isBoom(maybeBoom)) {
     // isBoom is a type guard that allows accessing these properties:
     maybeBoom.output.headers;
 }
@@ -183,7 +183,8 @@ interface CustomPayload extends Boom.Payload {
 /**
  * Test assignment of custom error data:
  */
-const errorWithData = Boom.badImplementation('', { custom1: 'test', customType: 'Custom1', isCustom: true } as CustomData1);
+// tslint:disable-next-line:no-object-literal-type-assertion
+const errorWithData = Boom.badImplementation('', <CustomData1> { custom1: 'test', customType: 'Custom1', isCustom: true });
 const errorWithNoExplicitDataType: Boom = errorWithData; // can assign to error without explicit data type
 const errorWithExplicitType: Boom<CustomData> = errorWithData; // can assign to union data type
 const errorWithConcreteCustomData: Boom<CustomData1> = errorWithData; // can assign to concrete data type

types/boom/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for boom 7.2.0
+// Type definitions for boom 7.2
 // Project: https://github.com/hapijs/boom
 // Definitions by: Igor Rogatty <https://github.com/rogatty>
 //                 AJP <https://github.com/AJamesPhillips>
@@ -10,28 +10,31 @@
 
  export = Boom;
 /**
-     * boom provides a set of utilities for returning HTTP errors. Each utility returns a Boom error response object (instance of Error) which includes the following properties:
-     * @see {@link https://github.com/hapijs/boom#boom}
-     */
+ * boom provides a set of utilities for returning HTTP errors. Each utility returns a Boom error response object (instance of Error) which includes the following properties:
+ * @see {@link https://github.com/hapijs/boom#boom}
+ */
 declare class Boom<Data = any> extends Error {
-
-        /** Creates a new Boom object using the provided message and then calling boomify() to decorate the error with the Boom properties. */
-        constructor(message?: string | Error, options?: Boom.Options<Data>);
-        /** isBoom - if true, indicates this is a Boom object instance. */
-        isBoom: boolean;
-        /** isServer - convenience bool indicating status code >= 500. */
-        isServer: boolean;
-        /** message - the error message. */
-        message: string;
-        /** output - the formatted response. Can be directly manipulated after object construction to return a custom error response. Allowed root keys: */
-        output: Boom.Output;
-        /** reformat() - rebuilds error.output using the other object properties. */
-        reformat: () => string;
-        /** "If message is unset, the 'error' segment of the header will not be present and isMissing will be true on the error object." mentioned in @see {@link https://github.com/hapijs/boom#boomunauthorizedmessage-scheme-attributes} */
-        isMissing?: boolean;
-        /** https://github.com/hapijs/boom#createstatuscode-message-data and https://github.com/hapijs/boom/blob/v4.3.0/lib/index.js#L99 */
-        data: Data;
-    }
+    /** Creates a new Boom object using the provided message and then calling boomify() to decorate the error with the Boom properties. */
+    constructor(message?: string | Error, options?: Boom.Options<Data>);
+    /** isBoom - if true, indicates this is a Boom object instance. */
+    isBoom: boolean;
+    /** isServer - convenience bool indicating status code >= 500. */
+    isServer: boolean;
+    /** message - the error message. */
+    message: string;
+    /** output - the formatted response. Can be directly manipulated after object construction to return a custom error response. Allowed root keys: */
+    output: Boom.Output;
+    /** reformat() - rebuilds error.output using the other object properties. */
+    reformat(): string;
+    /**
+     * "If message is unset, the 'error' segment of the header will not be present and
+     * isMissing will be true on the error object." mentioned in
+     * @see {@link https://github.com/hapijs/boom#boomunauthorizedmessage-scheme-attributes}
+     */
+    isMissing?: boolean;
+    /** https://github.com/hapijs/boom#createstatuscode-message-data and https://github.com/hapijs/boom/blob/v4.3.0/lib/index.js#L99 */
+    data: Data;
+}
 declare namespace Boom {
     interface Options<Data> {
         /** statusCode - the HTTP status code. Defaults to 500 if no status code is already set. */
@@ -44,20 +47,32 @@ declare namespace Boom {
         ctor?: any;
         /** message - error message string. If the error already has a message, the provided message is added as a prefix. Defaults to no message. */
         message?: string;
-        /** override - if false, the err provided is a Boom object, and a statusCode or message are provided, the values are ignored. Defaults to true (apply the provided statusCode and message options to the error regardless of its type, Error or Boom object). */
+        /**
+         * override - if false, the err provided is a Boom object, and a statusCode or message are
+         * provided, the values are ignored. Defaults to true (apply the provided statusCode and
+         * message options to the error regardless of its type, Error or Boom object).
+         */
         override?: boolean;
     }
 
     interface Output {
         /** statusCode - the HTTP status code (typically 4xx or 5xx). */
         statusCode: number;
-        /** headers - an object containing any HTTP headers where each key is a header name and value is the header content. (Limited value type to string https://github.com/hapijs/boom/issues/151 ) */
+        /**
+         * headers - an object containing any HTTP headers where each key is a header name and
+         * value is the header content. (Limited value type to string
+         * https://github.com/hapijs/boom/issues/151 )
+         */
         headers: {[index: string]: string};
-        /** payload - the formatted object used as the response payload (stringified). Can be directly manipulated but any changes will be lost if reformat() is called. Any content allowed and by default includes the following content: */
+        /**
+         * payload - the formatted object used as the response payload (stringified).
+         * Can be directly manipulated but any changes will be lost if reformat() is called.
+         * Any content allowed and by default includes the following content:
+         */
         payload: Payload;
     }
 
-     interface Payload {
+    interface Payload {
         /** statusCode - the HTTP status code, derived from error.output.statusCode. */
         statusCode: number;
         /** error - the HTTP status message (e.g. 'Bad Request', 'Internal Server Error') derived from statusCode. */
@@ -79,13 +94,13 @@ declare namespace Boom {
      * @param options optional additional options
      * @see {@link https://github.com/hapijs/boom#boomifyerror-options}
      */
-     function boomify(error: Error, options?: { statusCode?: number, message?: string, override?: boolean }): Boom<null>;
+    function boomify(error: Error, options?: { statusCode?: number, message?: string, override?: boolean }): Boom<null>;
 
     /**
      * Identifies whether an error is a Boom object. Same as calling instanceof Boom.
      * @param error the error object to identify.
      */
-     function isBoom(error: Error): error is Boom
+    function isBoom(error: Error): error is Boom;
 
     // 4xx
     /**
@@ -94,7 +109,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boombadrequestmessage-data}
      */
-     function badRequest<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function badRequest<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 401 Unauthorized error
@@ -102,13 +117,21 @@ declare namespace Boom {
      * @param scheme can be one of the following:
      *      * an authentication scheme name
      *      * an array of string values. These values will be separated by ', ' and set to the 'WWW-Authenticate' header.
-     * @param attributes an object of values to use while setting the 'WWW-Authenticate' header. This value is only used when scheme is a string, otherwise it is ignored. Every key/value pair will be included in the 'WWW-Authenticate' in the format of 'key="value"' as well as in the response payload under the attributes key. Alternatively value can be a string which is use to set the value of the scheme, for example setting the token value for negotiate header. If string is used message parameter must be null. null and undefined will be replaced with an empty string. If attributes is set, message will be used as the 'error' segment of the 'WWW-Authenticate' header. If message is unset, the 'error' segment of the header will not be present and isMissing will be true on the error object.
+     * @param attributes an object of values to use while setting the 'WWW-Authenticate' header.
+     * This value is only used when scheme is a string, otherwise it is ignored.
+     * Every key/value pair will be included in the 'WWW-Authenticate' in the format of
+     * 'key="value"' as well as in the response payload under the attributes key.
+     * Alternatively value can be a string which is use to set the value of the scheme,
+     * for example setting the token value for negotiate header.
+     * If string is used message parameter must be null.
+     * null and undefined will be replaced with an empty string. If attributes is set,
+     * message will be used as the 'error' segment of the 'WWW-Authenticate' header.
+     * If message is unset, the 'error' segment of the header will not be present and isMissing will be true on the error object.
      * @see {@link https://github.com/hapijs/boom#boomunauthorizedmessage-scheme-attributes}
      */
-     function unauthorized(message?: string, scheme?: string, attributes?: {[index: string]: string}): Boom<null>;
-     function unauthorized(message?: string, scheme?: string[]): Boom<null>;
-     function unauthorized(message?: null, scheme?: string, attributes?: {[index: string]: string} | string): Boom<null>;
-     function unauthorized(message?: null, scheme?: string[]): Boom<null>;
+    function unauthorized(message?: string, scheme?: string, attributes?: {[index: string]: string}): Boom<null>;
+    function unauthorized(message?: string, scheme?: string[]): Boom<null>;
+    function unauthorized(message?: null, scheme?: string, attributes?: {[index: string]: string} | string): Boom<null>;
 
     /**
      * Returns a 402 Payment Required error
@@ -116,7 +139,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boompaymentrequiredmessage-data}
      */
-     function paymentRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function paymentRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 403 Forbidden error
@@ -124,7 +147,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomforbiddenmessage-data}
      */
-     function forbidden<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function forbidden<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 404 Not Found error
@@ -132,7 +155,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomnotfoundmessage-data}
      */
-     function notFound<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function notFound<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 405 Method Not Allowed error
@@ -141,7 +164,7 @@ declare namespace Boom {
      * @param allow optional string or array of strings (to be combined and separated by ', ') which is set to the 'Allow' header.
      * @see {@link https://github.com/hapijs/boom#boommethodnotallowedmessage-data-allow}
      */
-     function methodNotAllowed<Data = null>(message?: string, data?: Data, allow?: string | string[]): Boom<Data>;
+    function methodNotAllowed<Data = null>(message?: string, data?: Data, allow?: string | string[]): Boom<Data>;
 
     /**
      * Returns a 406 Not Acceptable error
@@ -149,7 +172,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomnotacceptablemessage-data}
      */
-     function notAcceptable<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function notAcceptable<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 407 Proxy Authentication Required error
@@ -157,7 +180,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomproxyauthrequiredmessage-data}
      */
-     function proxyAuthRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function proxyAuthRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 408 Request Time-out error
@@ -165,7 +188,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomclienttimeoutmessage-data}
      */
-     function clientTimeout<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function clientTimeout<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 409 Conflict error
@@ -173,7 +196,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomconflictmessage-data}
      */
-     function conflict<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function conflict<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 410 Gone error
@@ -181,7 +204,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomresourcegonemessage-data}
      */
-     function resourceGone<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function resourceGone<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 411 Length Required error
@@ -189,7 +212,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomlengthrequiredmessage-data}
      */
-     function lengthRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function lengthRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 412 Precondition Failed error
@@ -197,7 +220,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boompreconditionfailedmessage-data}
      */
-     function preconditionFailed<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function preconditionFailed<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 413 Request Entity Too Large error
@@ -205,7 +228,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomentitytoolargemessage-data}
      */
-     function entityTooLarge<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function entityTooLarge<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 414 Request-URI Too Large error
@@ -213,7 +236,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomuritoolongmessage-data}
      */
-     function uriTooLong<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function uriTooLong<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 415 Unsupported Media Type error
@@ -221,7 +244,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomunsupportedmediatypemessage-data}
      */
-     function unsupportedMediaType<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function unsupportedMediaType<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 416 Requested Range Not Satisfiable error
@@ -229,7 +252,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomrangenotsatisfiablemessage-data}
      */
-     function rangeNotSatisfiable<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function rangeNotSatisfiable<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 417 Expectation Failed error
@@ -237,7 +260,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomexpectationfailedmessage-data}
      */
-     function expectationFailed<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function expectationFailed<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 418 I'm a Teapot error
@@ -245,7 +268,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomteapotmessage-data}
      */
-     function teapot<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function teapot<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 422 Unprocessable Entity error
@@ -253,7 +276,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boombaddatamessage-data}
      */
-     function badData<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function badData<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 423 Locked error
@@ -261,7 +284,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomlockedmessage-data}
      */
-     function locked<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function locked<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 424 Failed Dependency error
@@ -269,7 +292,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomfaileddependencymessage-data}
      */
-     function failedDependency<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function failedDependency<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 428 Precondition Required error
@@ -277,7 +300,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boompreconditionrequiredmessage-data}
      */
-     function preconditionRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function preconditionRequired<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 429 Too Many Requests error
@@ -285,7 +308,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomtoomanyrequestsmessage-data}
      */
-     function tooManyRequests<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function tooManyRequests<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 451 Unavailable For Legal Reasons error
@@ -293,7 +316,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomillegalmessage-data}
      */
-     function illegal<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function illegal<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     // 5xx
     /**
@@ -303,7 +326,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boombadimplementationmessage-data---alias-internal}
      */
-     function badImplementation<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function badImplementation<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 500 Internal Server Error error
@@ -312,7 +335,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boombadimplementationmessage-data---alias-internal}
      */
-     function internal<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function internal<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 501 Not Implemented error with your error message to the user
@@ -320,7 +343,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomnotimplementedmessage-data}
      */
-     function notImplemented<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function notImplemented<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 502 Bad Gateway error with your error message to the user
@@ -328,7 +351,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boombadgatewaymessage-data}
      */
-     function badGateway<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function badGateway<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 503 Service Unavailable error with your error message to the user
@@ -336,7 +359,7 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomserverunavailablemessage-data}
      */
-     function serverUnavailable<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function serverUnavailable<Data = null>(message?: string, data?: Data): Boom<Data>;
 
     /**
      * Returns a 504 Gateway Time-out error with your error message to the user
@@ -344,5 +367,5 @@ declare namespace Boom {
      * @param data optional additional error data.
      * @see {@link https://github.com/hapijs/boom#boomgatewaytimeoutmessage-data}
      */
-     function gatewayTimeout<Data = null>(message?: string, data?: Data): Boom<Data>;
+    function gatewayTimeout<Data = null>(message?: string, data?: Data): Boom<Data>;
 }

types/boom/tslint.json

@@ -1,79 +1,3 @@
 {
-    "extends": "dtslint/dt.json",
-    "rules": {
-        "adjacent-overload-signatures": false,
-        "array-type": false,
-        "arrow-return-shorthand": false,
-        "ban-types": false,
-        "callable-types": false,
-        "comment-format": false,
-        "dt-header": false,
-        "eofline": false,
-        "export-just-namespace": false,
-        "import-spacing": false,
-        "interface-name": false,
-        "interface-over-type-literal": false,
-        "jsdoc-format": false,
-        "max-line-length": false,
-        "member-access": false,
-        "new-parens": false,
-        "no-any-union": false,
-        "no-boolean-literal-compare": false,
-        "no-conditional-assignment": false,
-        "no-consecutive-blank-lines": false,
-        "no-construct": false,
-        "no-declare-current-package": false,
-        "no-duplicate-imports": false,
-        "no-duplicate-variable": false,
-        "no-empty-interface": false,
-        "no-for-in-array": false,
-        "no-inferrable-types": false,
-        "no-internal-module": false,
-        "no-irregular-whitespace": false,
-        "no-mergeable-namespace": false,
-        "no-misused-new": false,
-        "no-namespace": false,
-        "no-object-literal-type-assertion": false,
-        "no-padding": false,
-        "no-redundant-jsdoc": false,
-        "no-redundant-jsdoc-2": false,
-        "no-redundant-undefined": false,
-        "no-reference-import": false,
-        "no-relative-import-in-test": false,
-        "no-self-import": false,
-        "no-single-declare-module": false,
-        "no-string-throw": false,
-        "no-unnecessary-callback-wrapper": false,
-        "no-unnecessary-class": false,
-        "no-unnecessary-generics": false,
-        "no-unnecessary-qualifier": false,
-        "no-unnecessary-type-assertion": false,
-        "no-useless-files": false,
-        "no-var-keyword": false,
-        "no-var-requires": false,
-        "no-void-expression": false,
-        "no-trailing-whitespace": false,
-        "object-literal-key-quotes": false,
-        "object-literal-shorthand": false,
-        "one-line": false,
-        "one-variable-per-declaration": false,
-        "only-arrow-functions": false,
-        "prefer-conditional-expression": false,
-        "prefer-const": false,
-        "prefer-declare-function": false,
-        "prefer-for-of": false,
-        "prefer-method-signature": false,
-        "prefer-template": false,
-        "radix": false,
-        "semicolon": false,
-        "space-before-function-paren": false,
-        "space-within-parens": false,
-        "strict-export-declare-modifiers": false,
-        "trim-file": false,
-        "triple-equals": false,
-        "typedef-whitespace": false,
-        "unified-signatures": false,
-        "void-return": false,
-        "whitespace": false
-    }
+    "extends": "dtslint/dt.json"
 }

types/boom/v4/tsconfig.json

@@ -25,4 +25,4 @@
         "index.d.ts",
         "boom-tests.ts"
     ]
-}
+}

types/broccoli-plugin/broccoli-plugin-tests.ts

@@ -0,0 +1,46 @@
+import Plugin = require('broccoli-plugin');
+
+declare function copySync(src: string, dest: string): void;
+declare function setTimeout(callback: () => void, duration: number): void;
+
+class SlowItDown extends Plugin {
+    constructor(private readonly waitInMS: number) {
+        super([], {
+            annotation: `${waitInMS} ms`,
+            needsCache: false
+        });
+    }
+
+    async build() {
+        await new Promise(resolve => setTimeout(resolve, this.waitInMS));
+    }
+}
+
+class FileCopier extends Plugin {
+    constructor(inputNodes: Plugin.BroccoliNode[]) {
+        super(inputNodes, {
+            name: 'CopyFiles',
+            persistentOutput: true
+        });
+    }
+
+    build() {
+        for (const input of this.inputPaths) {
+            copySync(input, this.outputPath);
+        }
+    }
+
+    getCallbackObject() {
+        return this;
+    }
+}
+
+new FileCopier([
+    new SlowItDown(5000),
+    'src',
+    'assets'
+]);
+
+new Plugin(); // $ExpectError
+new Plugin([{}]); // $ExpectError
+new Plugin([], { foo: 'bar' }); // $ExpectError

types/broccoli-plugin/index.d.ts

@@ -0,0 +1,78 @@
+// Type definitions for broccoli-plugin 1.3
+// Project: https://github.com/broccolijs/broccoli-plugin
+// Definitions by: Dan Freeman <https://github.com/dfreeman>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
+export = BroccoliPlugin;
+
+declare namespace BroccoliPlugin {
+    type BroccoliNode = BroccoliPlugin | string;
+
+    interface BroccoliPluginOptions {
+        /**
+         * The name of this plugin. Defaults to `this.constructor.name`.
+         */
+        name?: string;
+
+        /**
+         * A descriptive annotation. Useful for debugging, to tell multiple
+         * instances of the same plugin apart.
+         */
+        annotation?: string;
+
+        /**
+         * If `true`, the output directory is not automatically emptied between
+         * builds. Defaults to `false`.
+         */
+        persistentOutput?: boolean;
+
+        /**
+         * If `true`, a cache directory is created automatically and the path is
+         * set at `cachePath`. If `false`, a cache directory is not created and
+         * `this.cachePath` is `undefined`. Defaults to `true`.
+         */
+        needsCache?: boolean;
+    }
+}
+
+declare class BroccoliPlugin {
+    constructor(inputNodes: BroccoliPlugin.BroccoliNode[], options?: BroccoliPlugin.BroccoliPluginOptions);
+
+    /**
+     * An array of paths on disk corresponding to each node in `inputNodes`.
+     * Your plugin will read files from these paths.
+     */
+    readonly inputPaths: ReadonlyArray<string>;
+
+    /**
+     * The path on disk corresponding to this plugin instance (this node).
+     * Your plugin will write files to this path. This directory is emptied by
+     * Broccoli before each build, unless the `persistentOutput` options is
+     * `true`.
+     */
+    readonly outputPath: string;
+
+    /**
+     * The path on disk to an auxiliary cache directory. Use this to store
+     * files that you want preserved between builds. This directory will
+     * only be deleted when Broccoli exits. If a cache directory is not
+     * needed, set `needsCache` to false when calling `broccoli-plugin`
+     * constructor.
+     */
+    readonly cachePath?: string;
+
+    /**
+     * Override this method in your subclass. It will be called on each
+     * (re-)build. All paths stay the same between builds.
+     * To perform asynchronous work, return a promise.
+     */
+    build(): void | Promise<any>;
+
+    /**
+     * Advanced usage only.
+     * Return the object on which Broccoli will call `obj.build()`. Called
+     * once after instantiation. By default, returns `this`.
+     */
+    getCallbackObject(): { build(): void | Promise<any> };
+}

types/broccoli-plugin/tsconfig.json

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

types/broccoli-plugin/tslint.json

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

types/bull/bull-tests.tsx

@@ -125,6 +125,7 @@ videoQueue.add({ video: 'http://example.com/video1.mov' }, { jobId: 1 })
 pdfQueue
 .on('error', (err: Error) => undefined)
 .on('active', (job: Queue.Job, jobPromise: Queue.JobPromise) => jobPromise.cancel())
+.on('waiting', (jobId: Queue.JobId) => undefined)
 .on('active', (job: Queue.Job) => undefined)
 .on('stalled', (job: Queue.Job) => undefined)
 .on('progress', (job: Queue.Job) => undefined)
@@ -132,4 +133,53 @@ pdfQueue
 .on('failed', (job: Queue.Job) => undefined)
 .on('paused', () => undefined)
 .on('resumed', () => undefined)
-.on('cleaned', (jobs: Queue.Job[], status: Queue.JobStatus) => undefined);
+.on('cleaned', (jobs: Queue.Job[], status: Queue.JobStatus) => undefined)
+.on('drained', () => undefined)
+.on('removed', (job: Queue.Job) => undefined);
+
+// test different process methods
+
+const profileQueue = new Queue('profile');
+// Max concurrency for requestProfile is 100
+profileQueue.process('requestProfile', 100, () => {});
+profileQueue.process(100, () => {});
+
+// other tests
+const myQueue = new Queue('myQueue', {
+    settings: {
+        drainDelay: 5
+    },
+    defaultJobOptions: {
+        stackTraceLimit: 1,
+    }
+});
+
+myQueue.on('active', (job: Queue.Job) => {
+    job.moveToCompleted();
+    job.moveToCompleted('done');
+    job.moveToCompleted('done', true);
+    job.moveToCompleted('done', true).then(val => {
+        if (val) {
+            const nextJobData: any = val[0];
+            const nextJobId: Queue.JobId = val[1];
+        }
+    });
+
+    job.moveToFailed({ message: "Call to external service failed!" }, true);
+    job.moveToFailed(new Error('test error'), true);
+    job.moveToFailed(new Error('test error'), true).then(val => {
+        if (val) {
+            const nextJobData: any = val[0];
+            const nextJobId: Queue.JobId = val[1];
+        }
+    });
+
+    job.discard();
+});
+
+// test all constructor options:
+
+new Queue('profile');
+new Queue('profile', 'url');
+new Queue('profile', { prefix: 'test' });
+new Queue('profile', 'url', { prefix: 'test' });

types/bull/index.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for bull 3.3
+// Type definitions for bull 3.4
 // Project: https://github.com/OptimalBits/bull
 // Definitions by: Bruno Grieder <https://github.com/bgrieder>
 //                 Cameron Crothers <https://github.com/JProgrammer>
@@ -10,6 +10,7 @@
 //                 Bond Akinmade <https://github.com/bondz>
 //                 Wuha Team <https://github.com/wuha-team>
 //                 Alec Brunelle <https://github.com/aleccool213>
+//                 Dan Manastireanu <https://github.com/danmana>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.8
 
@@ -23,9 +24,9 @@ import * as Promise from "bluebird";
  */
 declare const Bull: {
   (queueName: string, opts?: Bull.QueueOptions): Bull.Queue;
-  (queueName: string, url?: string): Bull.Queue; // tslint:disable-line unified-signatures
+  (queueName: string, url: string, opts?: Bull.QueueOptions): Bull.Queue; // tslint:disable-line unified-signatures
   new (queueName: string, opts?: Bull.QueueOptions): Bull.Queue;
-  new (queueName: string, url?: string): Bull.Queue; // tslint:disable-line unified-signatures
+  new (queueName: string, url: string, opts?: Bull.QueueOptions): Bull.Queue; // tslint:disable-line unified-signatures
 };
 
 declare namespace Bull {
@@ -92,6 +93,12 @@ declare namespace Bull {
     backoffStrategies?: {
       [key: string]: (attemptsMade: number, err: typeof Error) => number;
     };
+
+    /**
+     * A timeout for when the queue is in `drained` state (empty waiting for jobs).
+     * It is used when calling `queue.getNextJob()`, which will pass it to `.brpoplpush` on the Redis client.
+     */
+    drainDelay?: number;
   }
 
   type DoneCallback = (error?: Error | null, value?: any) => void;
@@ -141,6 +148,11 @@ declare namespace Bull {
      */
     retry(): Promise<void>;
 
+    /**
+     * Ensure this job is never ran again even if attemptsMade is less than job.attempts.
+     */
+    discard(): Promise<void>;
+
     /**
      * Returns a promise that resolves to the returned data when the job has been finished.
      * TODO: Add a watchdog to check if the job has finished periodically.
@@ -148,6 +160,18 @@ declare namespace Bull {
      */
     finished(): Promise<any>;
 
+    /**
+     * Moves a job to the `completed` queue. Pulls a job from 'waiting' to 'active'
+     * and returns a tuple containing the next jobs data and id. If no job is in the `waiting` queue, returns null.
+     */
+    moveToCompleted(returnValue?: string, ignoreLock?: boolean): Promise<[any, JobId] | null>;
+
+    /**
+     * Moves a job to the `failed` queue. Pulls a job from 'waiting' to 'active'
+     * and returns a tuple containing the next jobs data and id. If no job is in the `waiting` queue, returns null.
+     */
+    moveToFailed(errorInfo: { message: string; }, ignoreLock?: boolean): Promise<[any, JobId] | null>;
+
     /**
      * Promotes a job that is currently "delayed" to the "waiting" state and executed as soon as possible.
      */
@@ -205,6 +229,11 @@ declare namespace Bull {
      * Cron pattern specifying when the job should execute
      */
     cron: string;
+
+    /**
+     * Start date when the repeat job should start repeating (only with cron).
+     */
+    startDate?: Date | string | number;
   }
 
   interface EveryRepeatOptions extends RepeatOptions {
@@ -273,6 +302,11 @@ declare namespace Bull {
      * Default behavior is to keep the job in the completed set.
      */
     removeOnFail?: boolean;
+
+    /**
+     * Limits the amount of stack trace lines that will be recorded in the stacktrace.
+     */
+    stackTraceLimit?: number;
   }
 
   interface JobCounts {
@@ -618,6 +652,11 @@ declare namespace Bull {
      */
     on(event: 'error', callback: ErrorEventCallback): this;
 
+    /**
+     * A Job is waiting to be processed as soon as a worker is idling.
+     */
+    on(event: 'waiting', callback: WaitingEventCallback): this;
+
     /**
      * A job has started. You can use `jobPromise.cancel()` to abort it
      */
@@ -654,6 +693,11 @@ declare namespace Bull {
      */
     on(event: 'resumed', callback: EventCallback): this; // tslint:disable-line unified-signatures
 
+    /**
+     * A job successfully removed.
+     */
+    on(event: 'removed', callback: RemovedEventCallback<T>): this;
+
     /**
      * Old jobs have been cleaned from the queue.
      * `jobs` is an array of jobs that were removed, and `type` is the type of those jobs.
@@ -661,6 +705,12 @@ declare namespace Bull {
      * @see Queue#clean() for details
      */
     on(event: 'cleaned', callback: CleanedEventCallback<T>): this;
+
+    /**
+     * Emitted every time the queue has processed all the waiting jobs
+     * (even if there can be some delayed jobs not yet processed)
+     */
+    on(event: 'drained', callback: EventCallback): this; // tslint:disable-line unified-signatures
   }
 
   type EventCallback = () => void;
@@ -685,6 +735,10 @@ declare namespace Bull {
   type FailedEventCallback<T = any> = (job: Job<T>, error: Error) => void;
 
   type CleanedEventCallback<T = any> = (jobs: Array<Job<T>>, status: JobStatus) => void;
+
+  type RemovedEventCallback<T = any> = (job: Job<T>) => void;
+
+  type WaitingEventCallback = (jobId: JobId) => void;
 }
 
 export = Bull;

types/bunyan-winston-adapter/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/gluwer/bunyan-winston-adapter
 // Definitions by: Steve Hipwell <https://github.com/stevehipwell>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 import * as bunyan from "bunyan";
 import { Logger } from "winston";

types/catbox-redis/catbox-redis-tests.ts

@@ -1,6 +1,6 @@
 import * as CatbotRedis from 'catbox-redis';
 
-const cache = new CatbotRedis({
+const cache = new CatbotRedis<string>({
     host: 'localhost',
     partition: 'test',
     port: 2018,
@@ -10,3 +10,8 @@ cache.get({
     segment: 'test',
     id: 'test',
 });
+
+cache.set({
+    segment: 'test',
+    id: 'test',
+}, 'test', 123);

types/catbox-redis/index.d.ts

@@ -53,7 +53,7 @@ declare module 'catbox-redis' {
         sentinelName?: string;
       }
     }
-    class CatboxRedis extends Client {
+    class CatboxRedis<T> extends Client<T> {
       constructor(options: CatboxRedis.CatboxRedisOptions);
     }
     export = CatboxRedis;

types/catbox/catbox-tests.ts

@@ -1,16 +1,22 @@
-import { CacheItem, Client, Policy, EnginePrototypeOrObject } from "catbox";
+import { Client, Policy, EnginePrototypeOrObject, DecoratedResult, CachedObject } from "catbox";
 
 const Memory: EnginePrototypeOrObject = {
     async start(): Promise<void> {},
     stop(): void {},
-    async get(): Promise<null | CacheItem> {},
+    async get(): Promise<null | CachedObject<string>> {
+        return {
+            item: 'asd',
+            stored: 12,
+            ttl: 123,
+        };
+    },
     async set(): Promise<void> {},
     async drop(): Promise<void> {},
     isReady(): boolean { return true; },
     validateSegmentName(segment: string): null { return null; },
 };
 
-const client = new Client(Memory, { partition: 'cache' });
+const client = new Client<string>(Memory, { partition: 'cache' });
 
 const cache = new Policy({
     expiresIn: 5000,
@@ -25,3 +31,11 @@ cache.drop('foo').then(() => {});
 cache.isReady();
 
 cache.stats();
+
+const decoratedCache = new Policy({
+    getDecoratedValue: true,
+}, client, 'cache2');
+
+decoratedCache.get('test').then((a: DecoratedResult<string>) => {
+    const res: string = a.value;
+});

types/catbox/index.d.ts

@@ -4,7 +4,7 @@
 //                 AJP <https://github.com/AJamesPhillips>
 //                 Rodrigo Saboya <https://github.com/saboya>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.4
+// TypeScript Version: 2.8
 
 /**
  * Client
@@ -17,7 +17,7 @@
  *    the Riak bucket, or as a key prefix in Redis and Memcached. To share the cache across multiple clients, use the same partition name.
  * @see {@link https://github.com/hapijs/catbox#client}
  */
-export class Client implements ClientApi {
+export class Client<T> implements ClientApi<T> {
     constructor(engine: EnginePrototypeOrObject, options: ClientOptions);
 
     /** start() - creates a connection to the cache server. Must be called before any other method is available. */
@@ -28,14 +28,14 @@ export class Client implements ClientApi {
      * get(key, callback) - retrieve an item from the cache engine if found where:
      *  * key - a cache key object (see [ICacheKey]).
      */
-    get(key: CacheKey): Promise<null | CachedObject>;
+    get(key: CacheKey): Promise<null | CachedObject<T>>;
     /**
      * set(key, value, ttl, callback) - store an item in the cache for a specified length of time, where:
      *  * key - a cache key object (see [ICacheKey]).
      *  * value - the string or object value to be stored.
      *  * ttl - a time-to-live value in milliseconds after which the item is automatically removed from the cache (or is marked invalid).
      */
-    set(key: CacheKey, value: CacheItem, ttl: number): Promise<void>;
+    set(key: CacheKey, value: T, ttl: number): Promise<void>;
     /**
      * drop(key, callback) - remove an item from cache where:
      *  * key - a cache key object (see [ICacheKey]).
@@ -47,13 +47,13 @@ export class Client implements ClientApi {
     validateSegmentName(segment: string): null | Error;
 }
 
-export type EnginePrototypeOrObject = EnginePrototype | ClientApi;
+export type EnginePrototypeOrObject = EnginePrototype<any> | ClientApi<any>;
 
 /**
  * A prototype CatBox engine function
  */
-export interface EnginePrototype {
-    new(settings: ClientOptions): ClientApi;
+export interface EnginePrototype<T> {
+    new(settings: ClientOptions): ClientApi<T>;
 }
 
 /**
@@ -61,7 +61,7 @@ export interface EnginePrototype {
  * The Client object provides the following methods:
  * @see {@link https://github.com/hapijs/catbox#api}
  */
-export interface ClientApi {
+export interface ClientApi<T> {
     /** start() - creates a connection to the cache server. Must be called before any other method is available. */
     start(): Promise<void>;
     /** stop() - terminates the connection to the cache server. */
@@ -70,14 +70,14 @@ export interface ClientApi {
      * get(key, callback) - retrieve an item from the cache engine if found where:
      *  * key - a cache key object (see [ICacheKey]).
      */
-    get(key: CacheKey): Promise<null | CachedObject>;
+    get(key: CacheKey): Promise<null | CachedObject<T>>;
     /**
      * set(key, value, ttl) - store an item in the cache for a specified length of time, where:
      *  * key - a cache key object (see [ICacheKey]).
      *  * value - the string or object value to be stored.
      *  * ttl - a time-to-live value in milliseconds after which the item is automatically removed from the cache (or is marked invalid).
      */
-    set(key: CacheKey, value: CacheItem, ttl: number): Promise<void>;
+    set(key: CacheKey, value: T, ttl: number): Promise<void>;
     /**
      * drop(key) - remove an item from cache where:
      *  * key - a cache key object (see [ICacheKey]).
@@ -100,17 +100,15 @@ export interface CacheKey {
 }
 
 /** Cached object contains the following: */
-export interface CachedObject {
+export interface CachedObject<T> {
     /** item - the value stored in the cache using set(). */
-    item: any;
+    item: T;
     /** stored - the timestamp when the item was stored in the cache (in milliseconds). */
     stored: number;
     /** ttl - the remaining time-to-live (not the original value used when storing the object). */
     ttl: number;
 }
 
-export type CacheItem = any;
-
 export interface ClientOptions {
     /**
      * this will store items under keys that start with this value.
@@ -118,89 +116,69 @@ export interface ClientOptions {
     partition: string;
 }
 
+export type PolicyOptionVariants<T> = PolicyOptions<T> | DecoratedPolicyOptions<T>;
+
 /**
- * The Policy object provides a convenient cache interface by setting a global policy which is automatically applied to every storage action.
+ * The Policy object provides a convenient cache interface by setting a
+ * global policy which is automatically applied to every storage action.
  * The object is constructed using new Policy(options, [cache, segment]) where:
  *  * options - an object with the IPolicyOptions structure
  *  * cache - a Client instance (which has already been started).
- *  * segment - required when cache is provided. The segment name used to isolate cached items within the cache partition.
+ *  * segment - required when cache is provided. The segment name used to
+ * isolate cached items within the cache partition.
  * @see {@link https://github.com/hapijs/catbox#policy}
  */
-export class Policy implements PolicyAPI {
-    constructor(options: PolicyOptions, cache: Client, segment: string);
+export class Policy<T, O extends PolicyOptionVariants<T>> {
+    constructor(options: O, cache: Client<T>, segment: string);
     /**
-     * get(id) - retrieve an item from the cache. If the item is not found and the generateFunc method was provided,
-     * a new value is generated, stored in the cache, and returned. Multiple concurrent requests are queued and processed once. The method arguments are:
-     *  * id - the unique item identifier (within the policy segment). Can be a string or an object with the required 'id' key.
+     *  retrieve an item from the cache. If the item is not
+     * found and the generateFunc method was provided,
+     * a new value is generated, stored in the cache, and returned.
+     * Multiple concurrent requests are queued and processed once. The method arguments are:
+     * @param id the unique item identifier (within the policy segment).
+     * Can be a string or an object with the required 'id' key.
      */
-    get(id: string | { id: string }): Promise<PolicyGetPromiseResult | null>;
+    get(id: string | { id: string }): Promise<O extends DecoratedPolicyOptions<T> ? DecoratedResult<T> : T | null>;
+
     /**
-     * set(id, value, ttl) - store an item in the cache where:
-     *  * id - the unique item identifier (within the policy segment).
-     *  * value - the string or object value to be stored.
-     *  * ttl - a time-to-live override value in milliseconds after which the item is automatically removed from the cache (or is marked invalid).
+     * store an item in the cache where:
+     * @param id - the unique item identifier (within the policy segment).
+     * @param value - the string or object value to be stored.
+     * @param ttl - a time-to-live override value in milliseconds after which the item is automatically
+     * removed from the cache (or is marked invalid).
      *    This should be set to 0 in order to use the caching rules configured when creating the Policy object.
      */
-    set(id: string | { id: string }, value: CacheItem, ttl: number | null): Promise<void>;
+    set(id: string | { id: string }, value: T, ttl?: number): Promise<void>;
     /**
-     * drop(id) - remove the item from cache where:
-     *  * id - the unique item identifier (within the policy segment).
+     * remove the item from cache where:
+     * @param id the unique item identifier (within the policy segment).
      */
     drop(id: string | { id: string }): Promise<void>;
-    /** ttl(created) - given a created timestamp in milliseconds, returns the time-to-live left based on the configured rules. */
+    /**
+     * given a created timestamp in milliseconds, returns the time-to-live left
+     * based on the configured rules.
+     */
     ttl(created: number): number;
-    /** rules(options) - changes the policy rules after construction (note that items already stored will not be affected) */
-    rules(options: PolicyOptions): void;
-    /** isReady() - returns true if cache engine determines itself as ready, false if it is not ready or if there is no cache engine set. */
+    /** changes the policy rules after construction (note that items already stored will not be affected) */
+    rules(options: PolicyOptions<T>): void;
+    /**
+     * returns true if cache engine determines itself as ready, false if it is not ready or if
+     * here is no cache engine set.
+     */
     isReady(): boolean;
-    /** stats - an object with cache statistics */
+    /** an object with cache statistics */
     stats(): CacheStatisticsObject;
 }
 
-/**
- * Policy API
- * The Policy object provides the following methods:
- * @see {@link https://github.com/hapijs/catbox#api-1}
- */
-export interface PolicyAPI {
-    /**
-     * get(id) - retrieve an item from the cache. If the item is not found and the generateFunc method was provided,
-     * a new value is generated, stored in the cache, and returned. Multiple concurrent requests are queued and processed once. The method arguments are:
-     *  * id - the unique item identifier (within the policy segment). Can be a string or an object with the required 'id' key.
-     */
-    get(id: string | { id: string }): Promise<PolicyGetPromiseResult | null>;
-    /**
-     * set(id, value, ttl) - store an item in the cache where:
-     *  * id - the unique item identifier (within the policy segment).
-     *  * value - the string or object value to be stored.
-     *  * ttl - a time-to-live override value in milliseconds after which the item is automatically removed from the cache (or is marked invalid).
-     *    This should be set to 0 in order to use the caching rules configured when creating the Policy object.
-     */
-    set(id: string | { id: string }, value: CacheItem, ttl: number | null): Promise<void>;
-    /**
-     * drop(id) - remove the item from cache where:
-     *  * id - the unique item identifier (within the policy segment).
-     */
-    drop(id: string | { id: string }): Promise<void>;
-    /** ttl(created) - given a created timestamp in milliseconds, returns the time-to-live left based on the configured rules. */
-    ttl(created: number): number;
-    /** rules(options) - changes the policy rules after construction (note that items already stored will not be affected) */
-    rules(options: PolicyOptions): void;
-    /** isReady() - returns true if cache engine determines itself as ready, false if it is not ready or if there is no cache engine set. */
-    isReady(): boolean;
-    /** stats - an object with cache statistics */
-    stats(): CacheStatisticsObject;
-}
-
-export interface PolicyGetPromiseResult {
-    value: CacheItem;
-    cached: PolicyGetCachedOptions;
+export interface DecoratedResult<T> {
+    value: T;
+    cached: PolicyGetCachedOptions<T>;
     report: PolicyGetReportLog;
 }
 
-export interface PolicyGetCachedOptions {
+export interface PolicyGetCachedOptions<T> {
     /** item - the cached value. */
-    item: CacheItem;
+    item: T;
     /** stored - the timestamp when the item was stored in the cache. */
     stored: number;
     /** ttl - the cache ttl value for the record. */
@@ -212,13 +190,13 @@ export interface PolicyGetCachedOptions {
 /**
  * @see {@link https://github.com/hapijs/catbox#policy}
  */
-export interface PolicyOptions {
+export interface PolicyOptions<T> {
     /** expiresIn - relative expiration expressed in the number of milliseconds since the item was saved in the cache. Cannot be used together with expiresAt. */
     expiresIn?: number;
     /** expiresAt - time of day expressed in 24h notation using the 'HH:MM' format, at which point all cache records for the route expire. Uses local time. Cannot be used together with expiresIn. */
     expiresAt?: string;
     /** generateFunc - a function used to generate a new cache item if one is not found in the cache when calling get(). The method's signature is function(id, next) where: */
-    generateFunc?: GenerateFunc;
+    generateFunc?: GenerateFunc<T>;
     /**
      * staleIn - number of milliseconds to mark an item stored in cache as stale and attempt to regenerate it when generateFunc is provided.
      * Must be less than expiresIn. Alternatively function that returns staleIn value in milliseconds. The function signature is function(stored, ttl) where:
@@ -242,11 +220,18 @@ export interface PolicyOptions {
     generateIgnoreWriteError?: boolean;
     /**
      * pendingGenerateTimeout - number of milliseconds while generateFunc call is in progress for a given id, before a subsequent generateFunc call is allowed.
-     * Defaults to 0, no blocking of concurrent generateFunc calls beyond staleTimeout.
+     * @default 0, no blocking of concurrent generateFunc calls beyond staleTimeout.
      */
     pendingGenerateTimeout?: number;
 }
 
+export interface DecoratedPolicyOptions<T> extends PolicyOptions<T> {
+    /**
+     * @default false
+     */
+    getDecoratedValue?: boolean;
+}
+
 export interface GenerateFuncFlags {
     ttl: number;
 }
@@ -262,7 +247,7 @@ export interface GenerateFuncFlags {
  *      * ttl - the cache ttl value in milliseconds. Set to 0 to skip storing in the cache. Defaults to the cache global policy.
  * @see {@link https://github.com/hapijs/catbox#policy}
  */
-export type GenerateFunc = (id: string, flags: GenerateFuncFlags) => Promise<CacheItem>;
+export type GenerateFunc<T> = (id: string, flags: GenerateFuncFlags) => Promise<T>;
 
 /**
  * An object with logging information about the generation operation containing the following keys (as relevant):

types/chai-fs/index.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for chai-fs 2.0
 // Project: https://github.com/chaijs/chai-fs
-// Definitions by: Dimitar Danailov <https://github.com/Nemo157>
+// Definitions by: Dimitar Danailov <https://github.com/dimitardanailov>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.2
 

types/chai/chai-tests.ts

@@ -808,6 +808,24 @@ function frozen() {
     expect(Object.freeze({})).to.be.frozen;
     ({}).should.be.not.frozen;
     Object.freeze({}).should.be.frozen;
+
+    expect([1, 2, 3]).to.have.all.members([1, 2, 3]);
+    expect([1, 2, 3]).to.have.all.members(Object.freeze([1, 2, 3]));
+
+    expect({1: "", 2: "", 3: ""}).to.have.all.keys([1, 2, 3]);
+    expect({1: "", 2: "", 3: ""}).to.have.all.keys(Object.freeze([1, 2, 3]));
+
+    assert.notDeepInclude([1, 2, 3], 1);
+    assert.notDeepInclude(Object.freeze([1, 2, 3]), 1);
+
+    assert.include([1, 2, 3], 1);
+    assert.include(Object.freeze([1, 2, 3]), 1);
+
+    assert.notInclude([1, 2, 3], 1);
+    assert.notInclude(Object.freeze([1, 2, 3]), 1);
+
+    expect([1, 2, 3]).to.have.oneOf([1, 2, 3]);
+    expect([1, 2, 3]).to.have.oneOf(Object.freeze([1, 2, 3]));
 }
 
 class PoorlyConstructedError {

types/chai/index.d.ts

@@ -118,7 +118,7 @@ declare namespace Chai {
         extensible: Assertion;
         sealed: Assertion;
         frozen: Assertion;
-        oneOf(list: any[], message?: string): Assertion;
+        oneOf(list: ReadonlyArray<any>, message?: string): Assertion;
     }
 
     interface LanguageChains {
@@ -235,7 +235,7 @@ declare namespace Chai {
 
     interface Keys {
         (...keys: string[]): Assertion;
-        (keys: any[]|Object): Assertion;
+        (keys: ReadonlyArray<any>|Object): Assertion;
     }
 
     interface Throw {
@@ -252,7 +252,7 @@ declare namespace Chai {
     }
 
     interface Members {
-        (set: any[], message?: string): Assertion;
+        (set: ReadonlyArray<any>, message?: string): Assertion;
     }
 
     interface PropertyChange {
@@ -696,7 +696,7 @@ declare namespace Chai {
          * @param needle   Potential value contained in haystack.
          * @param message   Message to display on error.
          */
-        include<T>(haystack: T[], needle: T, message?: string): void;
+        include<T>(haystack: ReadonlyArray<T>, needle: T, message?: string): void;
 
         /**
          * Asserts that haystack does not include needle.
@@ -705,7 +705,7 @@ declare namespace Chai {
          * @param needle   Potential expected substring of haystack.
          * @param message   Message to display on error.
          */
-        notInclude(haystack: string | any[], needle: any, message?: string): void;
+        notInclude(haystack: string | ReadonlyArray<any>, needle: any, message?: string): void;
 
         /**
          * Asserts that haystack includes needle. Can be used to assert the inclusion of a value in an array or a subset of properties in an object. Deep equality is used.
@@ -732,7 +732,7 @@ declare namespace Chai {
          * @param needle   Potential expected substring of haystack.
          * @param message   Message to display on error.
          */
-        notDeepInclude(haystack: string | any[], needle: any, message?: string): void;
+        notDeepInclude(haystack: string | ReadonlyArray<any>, needle: any, message?: string): void;
 
         /**
          * Asserts that ‘haystack’ includes ‘needle’. Can be used to assert the inclusion of a subset of properties in an object.

types/chart.js/index.d.ts

@@ -10,7 +10,6 @@
 //                 Guillaume Rodriguez <https://github.com/guillaume-ro-fr>
 //                 Simon Archer <https://github.com/archy-bold>
 //                 Ken Elkabany <https://github.com/braincore>
-//                 Slavik Nychkalo <https://github.com/gebeto>
 //                 Francesco Benedetto <https://github.com/frabnt>
 //                 Alexandros Dorodoulis <https://github.com/alexdor>
 //                 Manuel Heidrich <https://github.com/mahnuh>
@@ -481,7 +480,12 @@ declare namespace Chart {
         fontStyle?: string;
     }
 
-    interface TickOptions {
+    interface TickOptions extends NestedTickOptions {
+        minor?: NestedTickOptions | false;
+        major?: NestedTickOptions | false;
+    }
+
+    interface NestedTickOptions {
         autoSkip?: boolean;
         autoSkipPadding?: number;
         backdropColor?: ChartColor;

types/chartist/chartist-tests.ts

@@ -197,6 +197,7 @@ new Chartist.Bar('.ct-chart', {
 }, {
     // Default mobile configuration
     stackBars: true,
+    stackMode: 'accumulate',
     axisX: {
         labelInterpolationFnc: (value: string) => {
             return value.split(/\s+/).map((word: string) => {

types/chartist/index.d.ts

@@ -283,6 +283,7 @@ declare namespace Chartist {
          * If set to true this property will cause the series bars to be stacked and form a total for each series point. This will also influence the y-axis and the overall bounds of the chart. In stacked mode the seriesBarDistance property will have no effect.
          */
         stackBars?: boolean;
+        stackMode?: 'overlap' | 'accumulate';
 
         horizontalBars?: boolean;
         distributeSeries?: boolean;

types/chartmogul-node/common.d.ts

@@ -1,5 +1,5 @@
 export interface Map {
-    [key: string]: any
+    [key: string]: any;
 }
 export interface CursorParams {
     page?: number;
@@ -15,9 +15,9 @@ export interface Cursor {
     total_pages?: number;
 }
 export interface Entries<T> extends Cursor {
-    entries: T[]
+    entries: T[];
 }
-interface Summary {
+export interface Summary {
     current: number;
     previous: number;
     ['percentage-change']: number;
@@ -25,4 +25,4 @@ interface Summary {
 export interface EntriesSummary<T> {
     entries: T[];
     summary: Summary;
-}
+}

types/chrome-apps/index.d.ts

@@ -612,7 +612,10 @@ declare namespace chrome {
              * @deprecated Deprecated since Chrome 36. Use innerBounds or outerBounds.
              */
             maxHeight?: integer;
-            /** Type of window to create */
+            /**
+             * @deprecated Deprecated since Chrome 69. All app windows use the 'shell' window type.
+             * @description Type of window to create
+             **/
             type?: 'shell';
             /**
              * If true, the window will have its own shelf icon.
@@ -919,7 +922,8 @@ declare namespace chrome {
             level?: integer;
         }
         /**
-         * Device properties by which to filter the list of returned audio devices. If the filter is not set or set to {}, returned device list will contain all available audio devices.
+         * Device properties by which to filter the list of returned audio devices.
+         * If the filter is not set or set to {}, returned device list will contain all available audio devices.
          */
         interface Filter {
             /**
@@ -1083,8 +1087,9 @@ declare namespace chrome {
         function getDevices(callback: (devices: Device[]) => void): void;
 
         /**
-         * Get a list of Bluetooth devices known to the system, including paired and recently discovered devices.
-         * @param filter Since Chrome 67. Some criteria to filter the list of returned bluetooth devices. If the filter is not set or set to {}, returned device list will contain all bluetooth devices. Right now this is only supported in ChromeOS, for other platforms, a full list is returned.
+         * @since Chrome 67.
+         * @description Get a list of Bluetooth devices known to the system, including paired and recently discovered devices.
+         * @param filter Some criteria to filter the list of returned bluetooth devices. If the filter is not set or set to {}, returned device list will contain all bluetooth devices. Right now this is only supported in ChromeOS, for other platforms, a full list is returned.
          * @param callback Called when the search is completed.
          */
         function getDevices(filter: DeviceFilter, callback: (devices: Device[]) => void): void;
@@ -2082,12 +2087,12 @@ declare namespace chrome {
         /**
          * **Dev channel only.**
          * Sets image data to clipboard
-         * @param imageData The encoded image data. *Since Chrome 70. Warning: this is the current Beta channel.*
-         * @param type The type of image being passed. *Since Chrome 70. Warning: this is the current Beta channel.*
+         * @param imageData The encoded image data. *Since Chrome 71. Warning: this is the current Dev channel.*
+         * @param type The type of image being passed. *Since Chrome 71. Warning: this is the current Dev channel.*
          * @param [additionalItems] Additional data items for describing image data.
          *      The callback is called with chrome.runtime.lastError set to error code if there is an error.
          *      Requires clipboard and clipboardWrite permissions.
-         *      *Since Chrome 70. Warning: this is the current Beta channel.*
+         *      *Since Chrome 71. Warning: this is the current Dev channel.*
          * @param [callback]
          */
         function setImageData(imageData: ArrayBuffer, type: ImageType, additionalItems?: AdditionalItems, callback?: () => void): void;
@@ -3078,7 +3083,8 @@ declare namespace chrome {
             'document_end' |
             'document_idle';
         /**
-         * The origin of injected CSS.
+         * @since Chrome 66.
+         * @description The origin of injected CSS.
          **/
         type CSSOrigin =
             'author' |
@@ -5968,6 +5974,11 @@ declare namespace chrome {
             SSID?: S;
             /** The network signal strength. */
             SignalStrength?: integer;
+            /**
+             * @since Chrome 70
+             * @description The tethering state associated with the connection.
+             */
+            TetheringState?: string;
         }
         interface WiFiProperties<M extends ManagedObject = 'unmanaged',
             OF extends _internal_.ObjectFunction = 'getter',
@@ -6379,8 +6390,8 @@ declare namespace chrome {
             progress?: integer;
 
             /**
-             * Whether to show UI indicating that the app will visibly respond to clicks on the body of a notification.
-             * @since Chrome 32.
+             * @deprecated Deprecated since Chrome 67. This UI hint is ignored as of Chrome 67
+             * @description Whether to show UI indicating that the app will visibly respond to clicks on the body of a notification.
              */
             isClickable?: boolean;
 
@@ -6391,6 +6402,13 @@ declare namespace chrome {
              * @since Chrome 50
              */
             requireInteraction?: boolean;
+
+            /**
+             * @since Chrome 70.
+             * @description Indicates that no sounds or vibrations should be made when the notification is being shown.
+             * @default false
+             */
+            silent?: boolean;
         }
 
         /** The notification closed, either by the system or by user action. */
@@ -6405,8 +6423,10 @@ declare namespace chrome {
          */
         const onPermissionLevelChanged: chrome.events.Event<(level: string) => void>;
         /**
-         * The user clicked on a link for the app's notification settings.
-         * @since Chrome 32.
+         * @deprecated Deprecated since Chrome 65. Custom notification settings button is no longer supported.
+         * @description The user clicked on a link for the app's notification settings.
+         * As of Chrome 47, only ChromeOS has UI that dispatches this event.
+         * As of Chrome 65, that UI has been removed from ChromeOS, too.
          */
         const onShowSettings: chrome.events.Event<() => void>;
 
@@ -9319,7 +9339,10 @@ declare namespace chrome {
             /** The display mode height in native pixels. */
             heightInNativePixels: integer;
 
-            /** The display mode UI scale factor. */
+            /**
+             * @deprecated Deprecated since Chrome 70. Use `displayZoomFactor`
+             * @description The display mode UI scale factor.
+             **/
             uiScale: integer;
 
             /** The display mode device scale factor. */
@@ -9380,15 +9403,16 @@ declare namespace chrome {
              * If set to true, changes the display mode to unified desktop.
              * If set to false, unified desktop mode will be disabled.
              * This is only valid for the primary display.
-             * If provided, mirroringSourceId must not be provided and other properties may not apply. This is has no effect if not provided.
-             * @see(See enableUnifiedDesktop for details).
+             * If provided, mirroringSourceId must not be provided and other properties may not apply.
+             * This is has no effect if not provided.
+             * @see(See `enableUnifiedDesktop` for details).
              * @since Chrome 59
              * */
             isUnified?: boolean;
 
             /**
              * @requires(CrOS) Chrome OS only.
-             * @deprecated Deprecated since Chrome 68. Use *setMirrorMode*
+             * @deprecated Deprecated since Chrome 68. Use ´setMirrorMode´
              * @see setMirrorMode
              * @description
              * If set and not empty, enables mirroring for this display.
@@ -9416,7 +9440,7 @@ declare namespace chrome {
              * If set, updates the display's rotation.
              * Legal values are [0, 90, 180, 270].
              * The rotation is set clockwise, relative to the display's vertical position.
-             * It's applied after overscan paramter.
+             * It's applied after overscan parameter.
              */
             rotation?: 0 | 90 | 180 | 270;
 
@@ -9912,10 +9936,10 @@ declare namespace chrome {
             /** The language that this voice supports, in the form language-region. Examples: 'en', 'en-US', 'en-GB', 'zh-CN'. */
             lang?: string;
             /**
-             * This voice's gender.
-             * One of: 'male', or 'female'
+             * @deprecated Deprecated since Chrome 70. Gender is deprecated and will be ignored.
+             * @description This voice's gender.
              */
-            gender?: string;
+            gender?: 'male' | 'female';
             /** The name of the voice. */
             voiceName?: string;
             /** The ID of the extension providing this voice. */
@@ -9959,10 +9983,10 @@ declare namespace chrome {
             /** The extension ID of the speech engine to use, if known. */
             extensionId?: string;
             /**
-             * Gender of voice for synthesized speech.
-             * One of: 'male', or 'female'
+             * @deprecated Deprecated since Chrome 70. Gender is deprecated and will be ignored.
+             * @description Gender of voice for synthesized speech.
              */
-            gender?: string;
+            gender?: 'male' | 'female';
             /** The TTS event types the voice must support. */
             requiredEventTypes?: string[];
             /** The TTS event types that you are interested in listening to. If missing, all event types may be sent. */
@@ -10983,7 +11007,7 @@ declare namespace chrome {
          */
         class RequestMatcher {
             protected readonly typeGuard: 'RequestMatcher';
-            constructor (parameters?: RequestMatcherFields);
+            constructor(parameters?: RequestMatcherFields);
             public readonly instanceType: string;
         }
 
@@ -11001,7 +11025,7 @@ declare namespace chrome {
         /** Declarative event action that redirects a network request.  */
         class RedirectRequest {
             protected readonly typeGuard: 'RedirectRequest';
-            constructor (parameters: RedirectRequestParams);
+            constructor(parameters: RedirectRequestParams);
             public readonly instanceType: string;
         }
 
@@ -11036,7 +11060,7 @@ declare namespace chrome {
          */
         class RedirectByRegEx {
             protected readonly typeGuard: 'RedirectByRegEx';
-            constructor (parameters: RedirectByRegExParams);
+            constructor(parameters: RedirectByRegExParams);
             public readonly instanceType: string;
         }
 
@@ -11055,7 +11079,7 @@ declare namespace chrome {
          */
         class SetRequestHeader {
             protected readonly typeGuard: 'SetRequestHeader';
-            constructor (parameters: SetRequestHeaderParams);
+            constructor(parameters: SetRequestHeaderParams);
             public readonly instanceType: string;
         }
 
@@ -11072,7 +11096,7 @@ declare namespace chrome {
          */
         class RemoveRequestHeader {
             protected readonly typeGuard: 'RemoveRequestHeader';
-            constructor (parameters: RemoveRequestHeaderParams);
+            constructor(parameters: RemoveRequestHeaderParams);
             public readonly instanceType: string;
         }
 
@@ -11091,7 +11115,7 @@ declare namespace chrome {
          */
         class AddResponseHeader {
             protected readonly typeGuard: 'AddResponseHeader';
-            constructor (parameters: AddResponseHeaderParams);
+            constructor(parameters: AddResponseHeaderParams);
             public readonly instanceType: string;
         }
 
@@ -11107,7 +11131,7 @@ declare namespace chrome {
          */
         class RemoveResponseHeader {
             protected readonly typeGuard: 'RemoveResponseHeader';
-            constructor (parameters: RemoveResponseHeaderParams);
+            constructor(parameters: RemoveResponseHeaderParams);
             public readonly instanceType: string;
         }
 
@@ -11133,7 +11157,7 @@ declare namespace chrome {
          */
         class IgnoreRules {
             protected readonly typeGuard: 'IgnoreRules';
-            constructor (parameters: IgnoreRulesParams);
+            constructor(parameters: IgnoreRulesParams);
             public readonly instanceType: string;
         }
 
@@ -11150,7 +11174,7 @@ declare namespace chrome {
          */
         class SendMessageToExtension {
             protected readonly typeGuard: 'SendMessageToExtension';
-            constructor (parameters: SendMessageParams);
+            constructor(parameters: SendMessageParams);
             public readonly instanceType: string;
         }
 
@@ -11248,7 +11272,7 @@ declare namespace chrome {
          */
         class AddRequestCookie {
             protected readonly typeGuard: 'AddRequestCookie';
-            constructor (parameters: AddCookie<RequestCookie>);
+            constructor(parameters: AddCookie<RequestCookie>);
             public readonly instanceType: string;
         }
 
@@ -11259,7 +11283,7 @@ declare namespace chrome {
          */
         class AddResponseCookie {
             protected readonly typeGuard: 'AddResponseCookie';
-            constructor (parameters: AddCookie<ResponseCookie>);
+            constructor(parameters: AddCookie<ResponseCookie>);
             public readonly instanceType: string;
         }
 
@@ -11292,7 +11316,7 @@ declare namespace chrome {
              * @param modification Attributes that shall be overridden in cookies that machted the filter.
              *                     Attributes that are set to an empty string are removed.
              */
-            constructor (parameters: EditCookieParams<RequestCookie, RequestCookie>);
+            constructor(parameters: EditCookieParams<RequestCookie, RequestCookie>);
             public readonly instanceType: string;
         }
 
@@ -11306,7 +11330,7 @@ declare namespace chrome {
              * @param filter Filter for cookies that will be modified.All empty entries are ignored.
              * @param modification
              */
-            constructor (parameter: EditCookieParams<FilterResponseCookie, ResponseCookie>);
+            constructor(parameter: EditCookieParams<FilterResponseCookie, ResponseCookie>);
             public readonly instanceType: string;
         }
 
@@ -11316,7 +11340,7 @@ declare namespace chrome {
          */
         class RemoveRequestCookie {
             protected readonly typeGuard: 'RemoveRequestCookie';
-            constructor (parameters: RemoveCookieParams<RequestCookie>);
+            constructor(parameters: RemoveCookieParams<RequestCookie>);
             public readonly instanceType: string;
         }
 
@@ -11340,7 +11364,7 @@ declare namespace chrome {
          */
         class RemoveResponseCookie {
             protected readonly typeGuard: 'RemoveResponseCookie';
-            constructor (parameters: RemoveCookieParams<FilterResponseCookie>);
+            constructor(parameters: RemoveCookieParams<FilterResponseCookie>);
             public readonly instanceType: string;
         }
 
@@ -11518,7 +11542,7 @@ declare namespace chrome {
  */
 declare class HTMLAppViewElement extends HTMLElement {
     /** Create a new AppView tag */
-    constructor ();
+    constructor();
     /**
      * Requests another app to be embedded.
      * @param app The extension id of the app to be embedded.
@@ -11626,7 +11650,7 @@ declare class HTMLWebViewElement extends HTMLElement {
     src: string;
 
     /** Create a new element */
-    constructor ();
+    constructor();
 
     /**
      * Queries audio state.
@@ -11908,6 +11932,21 @@ declare class HTMLWebViewElement extends HTMLElement {
      */
     loadDataWithBaseUrl(dataUrl: string, baseUrl: string, virtualUrl?: string): void;
 
+    /**
+     * @since Chrome 71
+     * @description Sets spatial navigation state of the webview.
+     * @param enabled Spatial navigation state value.
+     */
+    setSpatialNavigationEnabled(enabled: boolean): void;
+
+    /**
+     * @since Chrome 71
+     * @description Queries whether spatial navigation is enabled for the webview.
+     * @param callback Callback that will provide the value of the spatial navigation state.
+     */
+    isSpatialNavigationEnabled(callback: (enabled: boolean) => void): void;
+
+
     /**
      * Forcibly kills the guest web page's renderer process.
      * This may affect multiple webview tags in the current app if they share the same process,

types/chrome-apps/test/index.ts

@@ -1114,6 +1114,7 @@ chrome.networking.onc.getNetworks({ 'networkType': 'All' }, (networkList) => {
         if (networkObj.WiFi) {
             // WiFi active :)
             console.log('Wifi BSID: ' + networkObj.WiFi.BSSID);
+            const state = networkObj.WiFi.TetheringState;
         }
         chrome.networking.onc.setProperties(networkObj.GUID || '', {
             WiFi: {
@@ -1124,6 +1125,19 @@ chrome.networking.onc.getNetworks({ 'networkType': 'All' }, (networkList) => {
         chrome.networking.onc.getProperties(networkObj.GUID || '', (props) => {
             const WiFiResult = props.WiFi;
         });
+        chrome.networking.onc.getState(networkObj.GUID || '', (state) => {
+            const wifiState = state.WiFi || {};
+            return wifiState.TetheringState;
+        });
+        chrome.networking.onc.getManagedProperties(networkObj.GUID || '', (result) => {
+            const wifiResult = result.WiFi;
+            if (wifiResult !== undefined) {
+                const managed = wifiResult.HexSSID;
+                if (managed !== undefined) {
+                    return managed.UserPolicy;
+                }
+            }
+        });
     }
 });
 

types/chrome/index.d.ts

@@ -4525,12 +4525,12 @@ declare namespace chrome.pageAction {
      * Shows the page action. The page action is shown whenever the tab is selected.
      * @param tabId The id of the tab for which you want to modify the page action.
      */
-    export function hide(tabId: number): void;
+    export function hide(tabId: number, callback?: () => void): void;
     /**
      * Shows the page action. The page action is shown whenever the tab is selected.
      * @param tabId The id of the tab for which you want to modify the page action.
      */
-    export function show(tabId: number): void;
+    export function show(tabId: number, callback?: () => void): void;
     /** Sets the title of the page action. This is displayed in a tooltip over the page action. */
     export function setTitle(details: TitleDetails): void;
     /** Sets the html document to be opened as a popup when the user clicks on the page action's icon. */

types/codemirror/index.d.ts

@@ -260,16 +260,7 @@ declare namespace CodeMirror {
         line should be either an integer or a line handle, and node should be a DOM node, which will be displayed below the given line.
         options, when given, should be an object that configures the behavior of the widget.
         Note that the widget node will become a descendant of nodes with CodeMirror-specific CSS classes, and those classes might in some cases affect it. */
-        addLineWidget(line: any, node: HTMLElement, options?: {
-            /** Whether the widget should cover the gutter. */
-            coverGutter?: boolean;
-            /** Whether the widget should stay fixed in the face of horizontal scrolling. */
-            noHScroll?: boolean;
-            /** Causes the widget to be placed above instead of below the text of the line. */
-            above?: boolean;
-            /** When true, will cause the widget to be rendered even if the line it is associated with is hidden. */
-            showIfHidden?: boolean;
-        }): CodeMirror.LineWidget;
+        addLineWidget(line: any, node: HTMLElement, options?: CodeMirror.LineWidgetOptions): CodeMirror.LineWidget;
 
 
         /** Programatically set the size of the editor (overriding the applicable CSS rules).
@@ -728,6 +719,17 @@ declare namespace CodeMirror {
         changed(): void;
     }
 
+    interface LineWidgetOptions {
+        /** Whether the widget should cover the gutter. */
+        coverGutter?: boolean;
+        /** Whether the widget should stay fixed in the face of horizontal scrolling. */
+        noHScroll?: boolean;
+        /** Causes the widget to be placed above instead of below the text of the line. */
+        above?: boolean;
+        /** When true, will cause the widget to be rendered even if the line it is associated with is hidden. */
+        showIfHidden?: boolean;
+    }
+
     interface EditorChange {
         /** Position (in the pre-change coordinate system) where the change started. */
         from: CodeMirror.Position;

types/consola/consola-tests.ts

@@ -0,0 +1,15 @@
+import * as consola from 'consola';
+
+consola.start('TEST');
+consola.info('TEST');
+consola.success('TEST');
+consola.error('TEST');
+
+const logger = new consola.Consola({
+    level: 30,
+});
+
+logger.start('TEST');
+logger.info('TEST');
+logger.success('TEST');
+logger.error('TEST');

types/consola/index.d.ts

@@ -0,0 +1,39 @@
+// Type definitions for consola 1.x
+// Project: https://github.com/nuxt/consola
+// Definitions by: Jungwoo An <https://github.com/Jungwoo-An>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.4
+
+export interface LevelType {
+    level: number;
+    color: string;
+    isError?: boolean;
+}
+
+export interface Reporter {
+    log(logObj: any): void;
+}
+
+export interface Option {
+    level?: number;
+    types?: LevelType;
+    reporters?: Reporter[];
+}
+
+export class Consola {
+    constructor(option?: Option);
+
+    add(reporter: Reporter): Consola;
+    remove(reporter: Reporter): Consola;
+    clear(): Consola;
+    withScope(scope: string): void;
+    start(...arguments: string[]): void;
+    success(...arguments: string[]): void;
+    info(...arguments: string[]): void;
+    error(...arguments: Array<string | Error>): void;
+}
+
+export function start(...arguments: string[]): void;
+export function success(...arguments: string[]): void;
+export function info(...arguments: string[]): void;
+export function error(...arguments: Array<string | Error>): void;

types/consola/tsconfig.json

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

types/consola/tslint.json

@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}

types/critters-webpack-plugin/critters-webpack-plugin-tests.ts

@@ -0,0 +1,10 @@
+import Critters from 'critters-webpack-plugin';
+
+new Critters({
+    compress: true,
+    external: true,
+    inlineFonts: false,
+    preloadFonts: true,
+    keyframes: 'critical',
+    noscriptFallback: true,
+});

types/critters-webpack-plugin/index.d.ts

@@ -0,0 +1,65 @@
+// Type definitions for critters-webpack-plugin 1.3
+// Project: https://github.com/GoogleChromeLabs/critters
+// Definitions by: Juan José González Giraldo <https://github.com/JuanJoseGonGi>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { Plugin } from 'webpack';
+
+export default Critters;
+declare class Critters extends Plugin {
+    constructor(options?: Critters.CrittersOptions);
+}
+
+declare namespace Critters {
+    interface CrittersOptions {
+        /**
+         * Inline styles from external stylesheets.
+         * @default true
+         */
+        external?: boolean;
+        /**
+         * The mechanism to use for lazy-loading stylesheets. [JS] indicates that a strategy requires JavaScript (falls back to <noscript>).
+         * - default: Move stylesheet links to the end of the document and insert preload meta tags in their place.
+         * - "body": Move all external stylesheet links to the end of the document.
+         * - "media": Load stylesheets asynchronously by adding media="not x" and removing once loaded. [JS]
+         * - "swap": Convert stylesheet links to preloads that swap to rel="stylesheet" once loaded. [JS]
+         * - "js": Inject an asynchronous CSS loader similar to LoadCSS and use it to load stylesheets. [JS]
+         * - "js-lazy": Like "js", but the stylesheet is disabled until fully loaded.
+         */
+        preload?: 'body' | 'media' | 'swap' | 'js' | 'js-lazy';
+        /**
+         * Add <noscript> fallback to JS-based strategies
+         */
+        noscriptFallback?: boolean;
+        /**
+         * Inline critical font-face rules.
+         * @default false
+         */
+        inlineFonts?: boolean;
+        /**
+         * Preloads critical fonts.
+         * @default true
+         */
+        preloadFonts?: boolean;
+        /**
+         * Shorthand for setting inlineFonts+preloadFonts - Values:
+         * - true to inline critical font-face rules and preload the fonts.
+         * - false to don"t inline any font-face rules and don"t preload fonts.
+         */
+        fonts?: boolean;
+        /**
+         * Controls which keyframes rules are inlined. - Values:
+         * - "critical": Inline keyframes rules used by the critical CSS.
+         * - "all" Inline all keyframes rules.
+         * - "none" Remove all keyframes rules
+         * @default "critical"
+         */
+        keyframes?: 'critical' | 'all' | 'none';
+        /**
+         * Compress resulting critical CSS.
+         * @default true
+         */
+        compress?: boolean;
+    }
+}

types/critters-webpack-plugin/tsconfig.json

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

types/critters-webpack-plugin/tslint.json

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

types/d3/index.d.ts

@@ -1,6 +1,9 @@
 // Type definitions for D3JS d3 standard bundle 5.0
 // Project: https://github.com/d3/d3
-// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -11,7 +14,11 @@
 
 export as namespace d3;
 
+/**
+ * Version number in format _Major.Minor.BugFix_, like 5.0.0.
+ */
 export const version: string;
+
 export * from 'd3-array';
 export * from 'd3-axis';
 export * from 'd3-brush';

types/d3/tsconfig.json

@@ -7,7 +7,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "strictFunctionTypes": true,
         "baseUrl": "../",
         "typeRoots": [

types/d3/v4/index.d.ts

@@ -1,6 +1,9 @@
 // Type definitions for D3JS d3 standard bundle 4.13
 // Project: https://github.com/d3/d3
-// Definitions by: Tom Wanzek <https://github.com/tomwanzek>, Alex Ford <https://github.com/gustavderdrache>, Boris Yankov <https://github.com/borisyankov>
+// Definitions by: Tom Wanzek <https://github.com/tomwanzek>
+//                 Alex Ford <https://github.com/gustavderdrache>
+//                 Boris Yankov <https://github.com/borisyankov>
+//                 denisname <https://github.com/denisname>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
@@ -8,7 +11,11 @@
 
 export as namespace d3;
 
+/**
+ * Version number in format _Major.Minor.BugFix_, like 4.13.0.
+ */
 export const version: string;
+
 export * from 'd3-array';
 export * from 'd3-axis';
 export * from 'd3-brush';

types/d3/v4/tsconfig.json

@@ -7,7 +7,7 @@
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,
-        "strictNullChecks": false,
+        "strictNullChecks": true,
         "strictFunctionTypes": true,
         "baseUrl": "../../",
         "typeRoots": [

types/datadog-tracer/index.d.ts

@@ -2,6 +2,8 @@
 // Project: https://github.com/rochdev/datadog-tracer-js#readme
 // Definitions by: Dinesh Saravanan Kumaraswamy <https://github.com/dineshsaravanan>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
+
 import * as opentracing from "opentracing";
 import { EventEmitter } from "events";
 

types/dd-trace/src/opentracing/span_context.d.ts

@@ -22,7 +22,7 @@ interface SpanContextLike {
     trace?: {
         started: number[],
         finished: number[]
-    }
+    };
 }
 
 export = DatadogSpanContext;

types/dev-ip/dev-ip-tests.ts

@@ -0,0 +1,13 @@
+import devIp = require("dev-ip");
+
+const ips = devIp();
+
+function main() {
+    if (typeof ips === "boolean") {
+        return;
+    }
+
+    ips.map(ip => `ip: ${ip}`);
+}
+
+main();

types/dev-ip/index.d.ts

@@ -0,0 +1,11 @@
+// Type definitions for dev-ip 1.0
+// Project: https://github.com/shakyshane/dev-ip
+// Definitions by: Mike Engel <https://github.com/mike-engel>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/**
+ * Returns either an array of IP addresses or false if none can be found (offline, etc)
+ */
+declare function devIp(): string[] | boolean;
+
+export = devIp;

types/dev-ip/tsconfig.json

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

types/dev-ip/tslint.json

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

types/dotenv-safe/index.d.ts

@@ -2,7 +2,6 @@
 // Project: https://github.com/rolodato/dotenv-safe
 // Definitions by: Stan Goldmann <https://github.com/krenor>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
 
 import env = require("dotenv")
 

types/dotenv-safe/tsconfig.json

@@ -2,7 +2,7 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es5"
+            "es6"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,

types/doubleclick-gpt/doubleclick-gpt-tests.ts

@@ -41,7 +41,7 @@ googletag.openConsole();
 
 googletag.setAdIframeTitle("title");
 
-googletag.cmd.push(function() {
+googletag.cmd.push(() => {
     googletag.defineSlot("/1234567/sports", [160, 600]).
             addService(googletag.pubads());
 });
@@ -79,8 +79,8 @@ googletag.pubads().definePassback("/1234567/sports", [468, 60]).
             display();
 
 googletag.pubads().definePassback("/1234567/sports", [160, 600]).
-    updateTargetingFromMap({"color": "red",
-                                                    "interests": ["sports", "music", "movies"]}).
+    updateTargetingFromMap({color: "red",
+                            interests: ["sports", "music", "movies"]}).
             display();
 
 googletag.pubads().enableLazyLoad();
@@ -262,7 +262,7 @@ googletag.pubads().updateCorrelator();
 // The listener will be called only when the pubads service renders a slot.
 // To listen to companion ads, add a similar listener to
 // googletag.companionAds().
-googletag.pubads().addEventListener("slotRenderEnded", function(event: googletag.events.SlotRenderEndedEvent) {
+googletag.pubads().addEventListener("slotRenderEnded", (event: googletag.events.SlotRenderEndedEvent) => {
     console.log("Slot has been rendered:");
     console.log(event);
 });
@@ -273,7 +273,7 @@ googletag.pubads().addEventListener("slotRenderEnded", function(event: googletag
 // however, programmatically filter a listener to respond only to a certain
 // ad slot, using this pattern:
 let targetSlot = slot1;
-googletag.pubads().addEventListener("slotRenderEnded", function(event: googletag.events.SlotRenderEndedEvent) {
+googletag.pubads().addEventListener("slotRenderEnded", (event: googletag.events.SlotRenderEndedEvent) => {
     if (event.slot === targetSlot) {
         // Slot specific logic.
     }
@@ -283,7 +283,7 @@ googletag.pubads().addEventListener("slotRenderEnded", function(event: googletag
 // The listener will be called when the impression is considered viewable.
 // This event also operates at service level, but, as above, you can filter
 // to respond only to a certain ad slot by using this pattern:
-googletag.pubads().addEventListener("impressionViewable", function(event: googletag.events.ImpressionViewableEvent) {
+googletag.pubads().addEventListener("impressionViewable", (event: googletag.events.ImpressionViewableEvent) => {
     if (event.slot === targetSlot) {
         // Slot specific logic.
     }
@@ -317,7 +317,6 @@ slot.clearCategoryExclusions();
 
 // Make an ad request. Any ad can be returned for the slot.
 
-
 slot = googletag.defineSlot("/1234567/sports", [160, 600], "div-1").
         setTargeting("allow_expandable", "true").
         setTargeting("interests", ["sports", "music", "movies"]).

types/doubleclick-gpt/index.d.ts

@@ -1,29 +1,30 @@
-// Type definitions for Google Publisher Tag v238
+// Type definitions for Google Publisher Tag 238.0
 // Project: https://developers.google.com/doubleclick-gpt/reference
 // Definitions by: John Wright <https://github.com/johngeorgewright>
 //                 Steven Joyce <https://github.com/steven-joyce>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 declare namespace googletag {
-    export type SingleSizeArray = number[];
+    type SingleSizeArray = number[];
 
-    export type NamedSize = string | string[];
+    type NamedSize = string | string[];
 
-    export type SingleSize = SingleSizeArray | NamedSize;
+    type SingleSize = SingleSizeArray | NamedSize;
 
-    export type MultiSize = SingleSize[];
+    type MultiSize = SingleSize[];
 
-    export type GeneralSize = SingleSize | MultiSize;
+    type GeneralSize = SingleSize | MultiSize;
 
-    export type SizeMapping = GeneralSize[];
+    type SizeMapping = GeneralSize[];
 
-    export type SizeMappingArray = SizeMapping[];
+    type SizeMappingArray = SizeMapping[];
 
-    export interface CommandArray {
-        push(f: Function): number;
+    interface CommandArray {
+        push(f: () => void): number;
     }
 
-    export interface Service {
+    interface Service {
         addEventListener(
           eventType: string,
             listener: (event: events.ImpressionViewableEvent | events.SlotOnloadEvent | events.SlotRenderEndedEvent | events.slotVisibilityChangedEvent) => void
@@ -31,29 +32,29 @@ declare namespace googletag {
         getSlots(): Slot[];
     }
 
-    export interface CompanionAdsService extends Service {
+    interface CompanionAdsService extends Service {
         enableSyncLoading(): void;
         setRefreshUnfilledSlots(value: boolean): void;
     }
 
-    export interface ContentService extends Service {
-        setContent(slot: Slot, content: String): void;
+    interface ContentService extends Service {
+        setContent(slot: Slot, content: string): void;
     }
 
-    export interface LazyLoadOptionsConfig {
-        fetchMarginPercent?: number,
-        renderMarginPercent?: number,
-        mobileScaling?: number
+    interface LazyLoadOptionsConfig {
+        fetchMarginPercent?: number;
+        renderMarginPercent?: number;
+        mobileScaling?: number;
     }
 
-    export interface ResponseInformation {
+    interface ResponseInformation {
         advertiserId: string;
         campaignId: string;
         creativeId?: number;
         lineItemId?: number;
     }
 
-    export interface SafeFrameConfig {
+    interface SafeFrameConfig {
         allowOverlayExpansion?: boolean;
         allowPushExpansion?: boolean;
         sandbox?: boolean;
@@ -78,7 +79,7 @@ declare namespace googletag {
         sizeMapping(): SizeMappingBuilder;
     }
 
-    export interface Slot {
+    interface Slot {
         addService(service: Service): Slot;
         clearCategoryExclusions(): Slot;
         clearTargeting(opt_key?: string): Slot;
@@ -100,7 +101,7 @@ declare namespace googletag {
         setTargeting(key: string, value: string | string[]): Slot;
     }
 
-    export interface PassbackSlot {
+    interface PassbackSlot {
         display(): void;
         get(key: string): string;
         set(key: string, value: string): PassbackSlot;
@@ -109,10 +110,10 @@ declare namespace googletag {
         setTagForChildDirectedTreatment(value: number): PassbackSlot;
         setTagForUnderAgeOfConsent(value: number): PassbackSlot;
         setTargeting(key: string, value: string | string[]): PassbackSlot;
-        updateTargetingFromMap(map: Object): PassbackSlot;
+        updateTargetingFromMap(map: object): PassbackSlot;
     }
 
-    export interface PubAdsService extends Service {
+    interface PubAdsService extends Service {
         clear(opt_slots?: Slot[]): boolean;
         clearCategoryExclusions(): PubAdsService;
         clearTagForChildDirectedTreatment(): PubAdsService;
@@ -148,23 +149,23 @@ declare namespace googletag {
         updateCorrelator(): PubAdsService;
     }
 
-    export interface SizeMappingBuilder {
+    interface SizeMappingBuilder {
         addSize(viewportSize: SingleSizeArray, slotSize: GeneralSize): SizeMappingBuilder;
         build(): SizeMappingArray;
     }
 
-    export namespace events {
-        export interface ImpressionViewableEvent {
+    namespace events {
+        interface ImpressionViewableEvent {
             serviceName: string;
             slot: Slot;
         }
 
-        export interface SlotOnloadEvent {
+        interface SlotOnloadEvent {
             serviceName: string;
             slot: Slot;
         }
 
-        export interface SlotRenderEndedEvent {
+        interface SlotRenderEndedEvent {
             advertiserId?: number;
             creativeId?: number;
             isEmpty: boolean;
@@ -176,7 +177,7 @@ declare namespace googletag {
             sourceAgnosticLineItemId?: number;
         }
 
-        export interface slotVisibilityChangedEvent {
+        interface slotVisibilityChangedEvent {
             inViewPercentage: number;
             serviceName: string;
             slot: Slot;

types/doubleclick-gpt/tsconfig.json

@@ -1,5 +1,4 @@
 {
-    "compileOnSave": false,
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
@@ -22,4 +21,4 @@
         "index.d.ts",
         "doubleclick-gpt-tests.ts"
     ]
-}
+}

types/doubleclick-gpt/tslint.json

@@ -1,79 +1,3 @@
 {
-    "extends": "dtslint/dt.json",
-    "rules": {
-        "adjacent-overload-signatures": false,
-        "array-type": false,
-        "arrow-return-shorthand": false,
-        "ban-types": false,
-        "callable-types": false,
-        "comment-format": false,
-        "dt-header": false,
-        "eofline": false,
-        "export-just-namespace": false,
-        "import-spacing": false,
-        "interface-name": false,
-        "interface-over-type-literal": false,
-        "jsdoc-format": false,
-        "max-line-length": false,
-        "member-access": false,
-        "new-parens": false,
-        "no-any-union": false,
-        "no-boolean-literal-compare": false,
-        "no-conditional-assignment": false,
-        "no-consecutive-blank-lines": false,
-        "no-construct": false,
-        "no-declare-current-package": false,
-        "no-duplicate-imports": false,
-        "no-duplicate-variable": false,
-        "no-empty-interface": false,
-        "no-for-in-array": false,
-        "no-inferrable-types": false,
-        "no-internal-module": false,
-        "no-irregular-whitespace": false,
-        "no-mergeable-namespace": false,
-        "no-misused-new": false,
-        "no-namespace": false,
-        "no-object-literal-type-assertion": false,
-        "no-padding": false,
-        "no-redundant-jsdoc": false,
-        "no-redundant-jsdoc-2": false,
-        "no-redundant-undefined": false,
-        "no-reference-import": false,
-        "no-relative-import-in-test": false,
-        "no-self-import": false,
-        "no-single-declare-module": false,
-        "no-string-throw": false,
-        "no-unnecessary-callback-wrapper": false,
-        "no-unnecessary-class": false,
-        "no-unnecessary-generics": false,
-        "no-unnecessary-qualifier": false,
-        "no-unnecessary-type-assertion": false,
-        "no-useless-files": false,
-        "no-var-keyword": false,
-        "no-var-requires": false,
-        "no-void-expression": false,
-        "no-trailing-whitespace": false,
-        "object-literal-key-quotes": false,
-        "object-literal-shorthand": false,
-        "one-line": false,
-        "one-variable-per-declaration": false,
-        "only-arrow-functions": false,
-        "prefer-conditional-expression": false,
-        "prefer-const": false,
-        "prefer-declare-function": false,
-        "prefer-for-of": false,
-        "prefer-method-signature": false,
-        "prefer-template": false,
-        "radix": false,
-        "semicolon": false,
-        "space-before-function-paren": false,
-        "space-within-parens": false,
-        "strict-export-declare-modifiers": false,
-        "trim-file": false,
-        "triple-equals": false,
-        "typedef-whitespace": false,
-        "unified-signatures": false,
-        "void-return": false,
-        "whitespace": false
-    }
+    "extends": "dtslint/dt.json"
 }

types/draft-js/index.d.ts

@@ -989,6 +989,8 @@ import getVisibleSelectionRect = Draft.Component.Selection.getVisibleSelectionRe
 import DraftEditorCommand = Draft.Model.Constants.DraftEditorCommand;
 import DraftDragType = Draft.Model.Constants.DraftDragType;
 import DraftBlockType = Draft.Model.Constants.DraftBlockType;
+import DraftBlockRenderConfig = Draft.Model.ImmutableData.DraftBlockRenderConfig;
+import DraftBlockRenderMap = Draft.Component.Base.DraftBlockRenderMap;
 import DraftInlineStyleType = Draft.Model.Constants.DraftInlineStyleType;
 import DraftEntityMutability = Draft.Model.Constants.DraftEntityMutability;
 import DraftEntityType = Draft.Model.Constants.DraftEntityType;
@@ -1039,6 +1041,8 @@ export {
     DraftEditorCommand,
     DraftDragType,
     DraftBlockType,
+    DraftBlockRenderConfig,
+    DraftBlockRenderMap,
     DraftInlineStyleType,
     DraftEntityType,
     DraftEntityMutability,

types/dragula/dragula-tests.ts

@@ -30,3 +30,14 @@ var drake = dragula({
     copy: true
 });
 drake.containers.push(document.querySelector('#container'));
+
+dragula([document.getElementById('left'), document.getElementById('right')])
+    .on('drag', function (el: Element) {
+        el.className = el.className.replace('ex-moved', '');
+    }).on('drop', function (el: Element) {
+        el.className += ' ex-moved';
+    }).on('over', function (el: Element, container: Element) {
+        container.className += ' ex-over';
+    }).on('out', function (el: Element, container: Element) {
+        container.className = container.className.replace('ex-over', '');
+    });

types/dragula/index.d.ts

@@ -33,7 +33,7 @@ declare namespace dragula {
         cancel(revert:boolean): void;
         cancel(): void;
         remove(): void;
-        on(events: string, callback: Function): void;
+        on(events: string, callback: Function): Drake;
         destroy(): void;
     }
 

types/egg-mock/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/eggjs/egg-mock
 // Definitions by: Eward Song <https://github.com/sheperdwind>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.3
+// TypeScript Version: 2.8
 
 import { Application, Context } from 'egg';
 

types/egjs__axes/tsconfig.json

@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,

types/egjs__axes/tslint.json

@@ -1 +1,9 @@
-{ "extends": "dtslint/dt.json" }
+{
+    "extends": "dtslint/dt.json",
+    "rules": {
+        // All are TODOs
+        "ban-types": false,
+        "interface-name": false,
+        "strict-export-declare-modifiers": false
+    }
+}

types/electron-notifications/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/blainesch/electron-notifications
 // Definitions by: Daniel Pereira <https://github.com/djpereira>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 import * as Electron from 'electron';
 

types/electron-notify/index.d.ts

@@ -2,7 +2,7 @@
 // Project: https://github.com/hankbao/electron-notify
 // Definitions by: Daniel Pereira <https://github.com/djpereira>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
 /// <reference types="electron" />
 

types/electron-spellchecker/index.d.ts

@@ -2,6 +2,7 @@
 // Project: https://github.com/paulcbetts/electron-spellchecker
 // Definitions by: Daniel Perez Alvarez <https://github.com/unindented>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.2
 
 /// <reference types="electron"/>
 

types/electron-spellchecker/tsconfig.json

@@ -2,7 +2,8 @@
     "compilerOptions": {
         "module": "commonjs",
         "lib": [
-            "es6"
+            "es6",
+            "dom"
         ],
         "noImplicitAny": true,
         "noImplicitThis": true,