diff --git a/types/acl/index.d.ts b/types/acl/index.d.ts
index 931452dc52631ae..69bc094285af16b 100644
--- a/types/acl/index.d.ts
+++ b/types/acl/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/optimalbits/node_acl
 // Definitions by: Qubo <https://github.com/tkQubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node"/>
 
diff --git a/types/amqp-connection-manager/index.d.ts b/types/amqp-connection-manager/index.d.ts
index 4ea1c9c725a8126..5863a5e314d837a 100644
--- a/types/amqp-connection-manager/index.d.ts
+++ b/types/amqp-connection-manager/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/benbria/node-amqp-connection-manager
 // Definitions by: rogierschouten <https://github.com/rogierschouten>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import { ConfirmChannel, Connection, Message, Options, Replies } from "amqplib";
 import { EventEmitter } from "events";
diff --git a/types/amqplib/index.d.ts b/types/amqplib/index.d.ts
index 77e5d19ca9b60b3..64a91ff97f4b556 100644
--- a/types/amqplib/index.d.ts
+++ b/types/amqplib/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/squaremo/amqp.node, http://squaremo.github.io/amqp.node
 // Definitions by: Michael Nahkies <https://github.com/mnahkies>, Ab Reitsma <https://github.com/abreits>, Nicolás Fantone <https://github.com/nfantone>, Nick Zelei <https://github.com/zelein>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/asana/index.d.ts b/types/asana/index.d.ts
index 4a0ce5a05ffa17f..e929be535a33b29 100644
--- a/types/asana/index.d.ts
+++ b/types/asana/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/Asana/node-asana
 // Definitions by: Qubo <https://github.com/tkqubo>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 import * as Promise from 'bluebird';
 
 declare namespace asana {
diff --git a/types/blue-tape/index.d.ts b/types/blue-tape/index.d.ts
index b0861246959b964..5e66a7fb2107119 100644
--- a/types/blue-tape/index.d.ts
+++ b/types/blue-tape/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/spion/blue-tape
 // Definitions by: Haoqun Jiang <https://github.com/sodatea>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/bluebird-global/index.d.ts b/types/bluebird-global/index.d.ts
index 8924a941dfb54b6..f022efed7a1088f 100644
--- a/types/bluebird-global/index.d.ts
+++ b/types/bluebird-global/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/kaatt/bluebird-global
 // Definitions by: d-ph <https://github.com/d-ph>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /*
  * 1. Why use `bluebird-global` instead of `bluebird`?
diff --git a/types/bluebird-retry/index.d.ts b/types/bluebird-retry/index.d.ts
index f2c930b6e06ceb8..4b4d16e7cc3055a 100644
--- a/types/bluebird-retry/index.d.ts
+++ b/types/bluebird-retry/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/demmer/bluebird-retry
 // Definitions by: Pascal Vomhoff <https://github.com/pvomhoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import Promise = require('bluebird');
 
diff --git a/types/bluebird/bluebird-tests.ts b/types/bluebird/bluebird-tests.ts
index 05ac5cc19c9ee3c..7ae18184a834f27 100644
--- a/types/bluebird/bluebird-tests.ts
+++ b/types/bluebird/bluebird-tests.ts
@@ -5,7 +5,7 @@
 
 // Note: try to maintain the ordering and separators, and keep to the pattern
 
-import Promise = require("bluebird");
+import * as Bluebird from "bluebird";
 
 let obj: object = {};
 let bool = false;
@@ -14,7 +14,7 @@ let str = '';
 let err: Error = new Error();
 let x: any = 0;
 let f: (...args: any[]) => any = () => {};
-let asyncfunc: (...args: any[]) => Promise<any>;
+let asyncfunc: (...args: any[]) => Bluebird<any>;
 let arr: any[];
 let exp: RegExp;
 let anyArr: any[];
@@ -73,18 +73,18 @@ let barArr: Bar[];
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-let numProm: Promise<number>;
-let strProm: Promise<string>;
-let anyProm: Promise<any>;
-let boolProm: Promise<boolean>;
-let objProm: Promise<object> = Promise.resolve(obj);
-let voidProm: Promise<void>;
+let numProm: Bluebird<number>;
+let strProm: Bluebird<string>;
+let anyProm: Bluebird<any>;
+let boolProm: Bluebird<boolean>;
+let objProm: Bluebird<object> = Bluebird.resolve(obj);
+let voidProm: Bluebird<void>;
 
-let fooProm: Promise<Foo> = Promise.resolve(foo);
-let barProm: Promise<Bar> = Promise.resolve(bar);
-let fooOrBarProm: Promise<Foo | Bar>;
-let bazProm: Promise<Baz> = Promise.resolve(baz);
-let quxProm: Promise<Qux> = Promise.resolve(qux);
+let fooProm: Bluebird<Foo> = Bluebird.resolve(foo);
+let barProm: Bluebird<Bar> = Bluebird.resolve(bar);
+let fooOrBarProm: Bluebird<Foo | Bar>;
+let bazProm: Bluebird<Baz> = Bluebird.resolve(baz);
+let quxProm: Bluebird<Qux> = Bluebird.resolve(qux);
 
 // - - - - - - - - - - - - - - - - -
 
@@ -100,12 +100,12 @@ let barThen: PromiseLike<Bar> = barProm;
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-let numArrProm: Promise<number[]>;
-let strArrProm: Promise<string[]>;
-let anyArrProm: Promise<any[]>;
+let numArrProm: Bluebird<number[]>;
+let strArrProm: Bluebird<string[]>;
+let anyArrProm: Bluebird<any[]>;
 
-let fooArrProm: Promise<Foo[]> = Promise.resolve(fooArr);
-let barArrProm: Promise<Bar[]>;
+let fooArrProm: Bluebird<Foo[]> = Bluebird.resolve(fooArr);
+let barArrProm: Bluebird<Bar[]>;
 
 // - - - - - - - - - - - - - - - - -
 
@@ -118,12 +118,12 @@ let barArrThen: PromiseLike<Bar[]>;
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-let numPromArr: Array<Promise<number>>;
-let strPromArr: Array<Promise<string>>;
-let anyPromArr: Array<Promise<any>>;
+let numPromArr: Array<Bluebird<number>>;
+let strPromArr: Array<Bluebird<string>>;
+let anyPromArr: Array<Bluebird<any>>;
 
-let fooPromArr: Array<Promise<Foo>>;
-let barPromArr: Array<Promise<Bar>>;
+let fooPromArr: Array<Bluebird<Foo>>;
+let barPromArr: Array<Bluebird<Bar>>;
 
 // - - - - - - - - - - - - - - - - -
 
@@ -137,19 +137,24 @@ let barThenArr: Array<PromiseLike<Bar>>;
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // booya!
-let fooThenArrThen: PromiseLike<Array<PromiseLike<Foo>>> = Promise.resolve(fooThenArr);
+let fooThenArrThen: PromiseLike<Array<PromiseLike<Foo>>> = Bluebird.resolve(fooThenArr);
 
-let fooResolver: Promise.Resolver<Foo>;
-let fooInspection: Promise.Inspection<Foo>;
-let fooInspectionPromise: Promise<Promise.Inspection<Foo>>;
+let fooResolver: Bluebird.Resolver<Foo>;
+let fooInspection: Bluebird.Inspection<Foo>;
+let fooInspectionPromise: Bluebird<Bluebird.Inspection<Foo>>;
 
-let fooInspectionArrProm: Promise<Array<Promise.Inspection<Foo>>>;
+let fooInspectionArrProm: Bluebird<Array<Bluebird.Inspection<Foo>>>;
 
-let BlueBird: typeof Promise;
+let BlueBird: typeof Bluebird;
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-let version: string = Promise.version;
+let nativeFooProm: Promise<Foo>;
+let nativeBarProm: Promise<Bar>;
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+let version: string = Bluebird.version;
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -161,16 +166,19 @@ let nodeCallbackFuncErrorOnly = (callback: (err: any) => void) => {};
 fooThen = fooProm;
 barThen = barProm;
 
+nativeFooProm = fooProm;
+nativeBarProm = barProm;
+
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = new Promise((resolve: (value: Foo) => void, reject: (reason: any) => void) => {
+fooProm = new Bluebird((resolve: (value: Foo) => void, reject: (reason: any) => void) => {
 	if (bool) {
 		resolve(foo);
 	} else {
 		reject(new Error(str));
 	}
 });
-fooProm = new Promise((resolve: (value: Foo) => void) => {
+fooProm = new Bluebird((resolve: (value: Foo) => void) => {
 	if (bool) {
 		resolve(foo);
 	}
@@ -179,14 +187,14 @@ fooProm = new Promise((resolve: (value: Foo) => void) => {
 // - - - - - - - - - - - - - - - - - - - - - - -
 
 // needs a hint when used untyped?
-fooProm = new Promise<Foo>((resolve, reject) => {
+fooProm = new Bluebird<Foo>((resolve, reject) => {
 	if (bool) {
 		resolve(fooThen);
 	} else {
 		reject(new Error(str));
 	}
 });
-fooProm = new Promise<Foo>((resolve) => {
+fooProm = new Bluebird<Foo>((resolve) => {
 	resolve(fooThen);
 });
 
@@ -232,7 +240,7 @@ barProm = fooProm.then((value: Foo) => {
 });
 barProm = barProm.then((value: Bar) => {
 	if (value) return value;
-	return Promise.resolve(bar);
+	return Bluebird.resolve(bar);
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -317,7 +325,7 @@ fooProm.catch(Error, (reason: any) => {
 	return;
 });
 // $ExpectType Bluebird<void | Foo>
-fooProm.catch(Promise.CancellationError, (reason: any) => {
+fooProm.catch(Bluebird.CancellationError, (reason: any) => {
 	return;
 });
 // $ExpectType Bluebird<void | Foo>
@@ -325,20 +333,20 @@ fooProm.caught(Error, (reason: any) => {
 	return;
 });
 // $ExpectType Bluebird<void | Foo>
-fooProm.caught(Promise.CancellationError, (reason: any) => {
+fooProm.caught(Bluebird.CancellationError, (reason: any) => {
 	return;
 });
 
 fooOrBarProm = fooProm.catch(Error, (reason: any) => {
 	return bar;
 });
-fooOrBarProm = fooProm.catch(Promise.CancellationError, (reason: any) => {
+fooOrBarProm = fooProm.catch(Bluebird.CancellationError, (reason: any) => {
 	return bar;
 });
 fooOrBarProm = fooProm.caught(Error, (reason: any) => {
 	return bar;
 });
-fooOrBarProm = fooProm.caught(Promise.CancellationError, (reason: any) => {
+fooOrBarProm = fooProm.caught(Bluebird.CancellationError, (reason: any) => {
 	return bar;
 });
 
@@ -505,7 +513,7 @@ fooProm = fooProm.tapCatch((err) => {
 });
 
 fooProm = fooProm.tapCatch(err => {
-	return Promise.resolve("foo");
+	return Bluebird.resolve("foo");
 });
 
 fooProm.tapCatch(CustomError, (err: CustomError) => {
@@ -624,35 +632,35 @@ fooProm.race();
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 let propsValue: { num: number, str: string };
-Promise.resolve({ num: 1, str: Promise.resolve('a') }).props().then(val => { propsValue = val; });
-Promise.props({ num: 1, str: Promise.resolve('a') }).then(val => { propsValue = val; });
-Promise.props(Promise.props({ num: 1, str: Promise.resolve('a') })).then(val => { propsValue = val; });
+Bluebird.resolve({ num: 1, str: Bluebird.resolve('a') }).props().then(val => { propsValue = val; });
+Bluebird.props({ num: 1, str: Bluebird.resolve('a') }).then(val => { propsValue = val; });
+Bluebird.props(Bluebird.props({ num: 1, str: Bluebird.resolve('a') })).then(val => { propsValue = val; });
 
 let propsMapValue: Map<number, string>;
-Promise.resolve(new Map<number, string>()).props().then(val => { propsMapValue = val; });
-Promise.resolve(new Map<number, PromiseLike<string>>()).props().then(val => { propsMapValue = val; });
-Promise.props(new Map<number, string>()).then(val => { propsMapValue = val; });
-Promise.props(new Map<number, PromiseLike<string>>()).then(val => { propsMapValue = val; });
+Bluebird.resolve(new Map<number, string>()).props().then(val => { propsMapValue = val; });
+Bluebird.resolve(new Map<number, PromiseLike<string>>()).props().then(val => { propsMapValue = val; });
+Bluebird.props(new Map<number, string>()).then(val => { propsMapValue = val; });
+Bluebird.props(new Map<number, PromiseLike<string>>()).then(val => { propsMapValue = val; });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-Promise.all([fooProm, barProm]).then(result => {
+Bluebird.all([fooProm, barProm]).then(result => {
   	foo = result[0];
   	bar = result[1];
 });
 
-Promise.all([fooProm, fooProm]).then(result => {
+Bluebird.all([fooProm, fooProm]).then(result => {
 	foo = result[0];
 	foo = result[1];
 });
 
-Promise.all([fooProm, barProm, bazProm]).then(result => {
+Bluebird.all([fooProm, barProm, bazProm]).then(result => {
 	foo = result[0];
 	bar = result[1];
 	baz = result[2];
 });
 
-Promise.all([fooProm, barProm, fooProm]).then(result => {
+Bluebird.all([fooProm, barProm, fooProm]).then(result => {
 	foo = result[0];
 	bar = result[1];
 	foo = result[2];
@@ -721,42 +729,42 @@ fooArrProm = fooArrProm.filter((item: Foo) => {
 fooArrProm = fooArrProm.each((item: Foo): Bar => bar);
 fooArrProm = fooArrProm.each((item: Foo, index: number) => index ? bar : null);
 fooArrProm = fooArrProm.each((item: Foo, index: number, arrayLength: number): Bar => bar);
-fooArrProm = fooArrProm.each((item: Foo, index: number, arrayLength: number): Promise<Bar> => barProm);
+fooArrProm = fooArrProm.each((item: Foo, index: number, arrayLength: number): Bluebird<Bar> => barProm);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = new Promise.Promise<Foo>((resolve, reject) => {
+fooProm = new Bluebird.Promise<Foo>((resolve, reject) => {
 	resolve(foo);
 });
-fooProm = Promise.Promise.try<Foo>(() => {
+fooProm = Bluebird.Promise.try<Foo>(() => {
 	return foo;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-function getMaybePromise(): Foo|Promise<Foo> {
+function getMaybePromise(): Foo|Bluebird<Foo> {
     return foo;
 }
 
-fooProm = Promise.try(() => {
+fooProm = Bluebird.try(() => {
 	return getMaybePromise();
 });
-fooProm = Promise.try<Foo>(() => {
+fooProm = Bluebird.try<Foo>(() => {
 	return getMaybePromise();
 });
-fooProm = Promise.try(() => {
+fooProm = Bluebird.try(() => {
 	return foo;
 });
 
 // - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.try(() => {
+fooProm = Bluebird.try(() => {
 	return fooThen;
 });
 
 // - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.try(() => {
+fooProm = Bluebird.try(() => {
     if (fooProm) {
         return fooProm;
     }
@@ -765,19 +773,19 @@ fooProm = Promise.try(() => {
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.attempt(() => {
+fooProm = Bluebird.attempt(() => {
 	return getMaybePromise();
 });
-fooProm = Promise.attempt<Foo>(() => {
+fooProm = Bluebird.attempt<Foo>(() => {
 	return getMaybePromise();
 });
-fooProm = Promise.attempt(() => {
+fooProm = Bluebird.attempt(() => {
 	return foo;
 });
 
 // - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.attempt(() => {
+fooProm = Bluebird.attempt(() => {
     if (fooProm) {
         return fooProm;
     }
@@ -786,31 +794,31 @@ fooProm = Promise.attempt(() => {
 
 // - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.attempt(() => {
+fooProm = Bluebird.attempt(() => {
 	return fooThen;
 });
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-asyncfunc = Promise.method(() => {});
+asyncfunc = Bluebird.method(() => {});
 {
-	const noArg: () => Promise<void> = Promise.method(() => {});
-	const oneArg: (x1: number) => Promise<void> = Promise.method((x1: number) => {});
-	const twoArg: (x1: number, x2: string) => Promise<void> = Promise.method((x1: number, x2: string) => {});
+	const noArg: () => Bluebird<void> = Bluebird.method(() => {});
+	const oneArg: (x1: number) => Bluebird<void> = Bluebird.method((x1: number) => {});
+	const twoArg: (x1: number, x2: string) => Bluebird<void> = Bluebird.method((x1: number, x2: string) => {});
 }
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.resolve(foo);
-fooProm = Promise.resolve(fooThen);
+fooProm = Bluebird.resolve(foo);
+fooProm = Bluebird.resolve(fooThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-voidProm = Promise.reject(reason);
+voidProm = Bluebird.reject(reason);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooResolver = Promise.defer<Foo>();
+fooResolver = Bluebird.defer<Foo>();
 
 fooResolver.resolve(foo);
 
@@ -820,38 +828,38 @@ fooResolver.callback = (err: any, value: Foo) => {};
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooProm = Promise.cast(foo);
-fooProm = Promise.cast(fooThen);
+fooProm = Bluebird.cast(foo);
+fooProm = Bluebird.cast(fooThen);
 
-voidProm = Promise.bind(x);
+voidProm = Bluebird.bind(x);
 
-bool = Promise.is(value);
+bool = Bluebird.is(value);
 
-Promise.longStackTraces();
+Bluebird.longStackTraces();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // TODO enable delay
 
-fooProm = Promise.delay(num, fooThen);
-fooProm = Promise.delay(num, foo);
-voidProm = Promise.delay(num);
+fooProm = Bluebird.delay(num, fooThen);
+fooProm = Bluebird.delay(num, foo);
+voidProm = Bluebird.delay(num);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-asyncfunc = Promise.promisify(f);
-asyncfunc = Promise.promisify(f, obj);
+asyncfunc = Bluebird.promisify(f);
+asyncfunc = Bluebird.promisify(f, obj);
 
-obj = Promise.promisifyAll(obj);
-anyProm = Promise.fromNode(nodeCallbackFunc);
-anyProm = Promise.fromNode(nodeCallbackFuncErrorOnly);
-anyProm = Promise.fromNode(nodeCallbackFunc, {multiArgs : true});
-anyProm = Promise.fromNode(nodeCallbackFuncErrorOnly, {multiArgs : true});
+obj = Bluebird.promisifyAll(obj);
+anyProm = Bluebird.fromNode(nodeCallbackFunc);
+anyProm = Bluebird.fromNode(nodeCallbackFuncErrorOnly);
+anyProm = Bluebird.fromNode(nodeCallbackFunc, {multiArgs : true});
+anyProm = Bluebird.fromNode(nodeCallbackFuncErrorOnly, {multiArgs : true});
 
-anyProm = Promise.fromCallback(nodeCallbackFunc);
-anyProm = Promise.fromCallback(nodeCallbackFuncErrorOnly);
-anyProm = Promise.fromCallback(nodeCallbackFunc, {multiArgs : true});
-anyProm = Promise.fromCallback(nodeCallbackFuncErrorOnly, {multiArgs : true});
+anyProm = Bluebird.fromCallback(nodeCallbackFunc);
+anyProm = Bluebird.fromCallback(nodeCallbackFuncErrorOnly);
+anyProm = Bluebird.fromCallback(nodeCallbackFunc, {multiArgs : true});
+anyProm = Bluebird.fromCallback(nodeCallbackFuncErrorOnly, {multiArgs : true});
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -867,14 +875,14 @@ function DOMPromisifier(originalMethod: (...args: any[]) => any) {
     // return a function
     return function promisified(this: object, ...args: any[]) {
         // which returns a promise
-        return new Promise((resolve, reject) => {
+        return new Bluebird((resolve, reject) => {
             args.push(resolve, reject);
             originalMethod.apply(this, args);
         });
     };
 }
 
-obj = Promise.promisifyAll(obj, {
+obj = Bluebird.promisifyAll(obj, {
 	suffix: "",
 	filter: defaultFilter,
 	promisifier: DOMPromisifier
@@ -883,67 +891,67 @@ obj = Promise.promisifyAll(obj, {
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 const generator1 = function*(a: number, b: string) { return "string"; };
-const coroutine1 = Promise.coroutine<string, number, string>(generator1);
+const coroutine1 = Bluebird.coroutine<string, number, string>(generator1);
 strProm = coroutine1(5, "foo");
 
 const generator2 = function*(a: number, b: string) {
 	yield foo;
 	return bar;
 };
-const coroutine2 = Promise.coroutine<Bar, number, string>(generator2);
+const coroutine2 = Bluebird.coroutine<Bar, number, string>(generator2);
 barProm = coroutine2(5, "foo");
 
-const coroutineCustomYield = Promise.coroutine(generator1, { yieldHandler: (value) => "whatever" });
+const coroutineCustomYield = Bluebird.coroutine(generator1, { yieldHandler: (value) => "whatever" });
 /*
- barProm = Promise.spawn<number>(f);
+ barProm = Bluebird.spawn<number>(f);
  */
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-BlueBird = Promise.getNewLibraryCopy();
-BlueBird = Promise.noConflict();
+BlueBird = Bluebird.getNewLibraryCopy();
+BlueBird = Bluebird.noConflict();
 
-Promise.onPossiblyUnhandledRejection((reason: any) => {});
+Bluebird.onPossiblyUnhandledRejection((reason: any) => {});
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // TODO expand tests to overloads
-fooArrProm = Promise.all(fooThenArrThen);
-fooArrProm = Promise.all(fooArrProm);
-fooArrProm = Promise.all(fooThenArr);
-fooArrProm = Promise.all(fooArr);
+fooArrProm = Bluebird.all(fooThenArrThen);
+fooArrProm = Bluebird.all(fooArrProm);
+fooArrProm = Bluebird.all(fooThenArr);
+fooArrProm = Bluebird.all(fooArr);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-objProm = Promise.props(objProm);
-objProm = Promise.props(obj);
+objProm = Bluebird.props(objProm);
+objProm = Bluebird.props(obj);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // TODO expand tests to overloads
-fooProm = Promise.any(fooThenArrThen);
-fooProm = Promise.any(fooArrProm);
-fooProm = Promise.any(fooThenArr);
-fooProm = Promise.any(fooArr);
+fooProm = Bluebird.any(fooThenArrThen);
+fooProm = Bluebird.any(fooArrProm);
+fooProm = Bluebird.any(fooThenArr);
+fooProm = Bluebird.any(fooArr);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // TODO expand tests to overloads
-fooProm = Promise.race(fooThenArrThen);
-fooProm = Promise.race(fooArrProm);
-fooProm = Promise.race(fooThenArr);
-fooProm = Promise.race(fooArr);
+fooProm = Bluebird.race(fooThenArrThen);
+fooProm = Bluebird.race(fooArrProm);
+fooProm = Bluebird.race(fooThenArr);
+fooProm = Bluebird.race(fooArr);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // TODO expand tests to overloads
-fooArrProm = Promise.some(fooThenArrThen, num);
-fooArrProm = Promise.some(fooThenArr, num);
-fooArrProm = Promise.some(fooArr, num);
+fooArrProm = Bluebird.some(fooThenArrThen, num);
+fooArrProm = Bluebird.some(fooThenArr, num);
+fooArrProm = Bluebird.some(fooArr, num);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
-fooArrProm = Promise.join(foo, foo, foo);
-fooArrProm = Promise.join(fooThen, fooThen, fooThen);
+fooArrProm = Bluebird.join(foo, foo, foo);
+fooArrProm = Bluebird.join(fooThen, fooThen, fooThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
@@ -953,35 +961,35 @@ fooArrProm = Promise.join(fooThen, fooThen, fooThen);
 
 // fooThenArrThen
 
-barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
-barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo) => {
 	return barThen;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, {
 	concurrency: 1
@@ -990,35 +998,35 @@ barArrProm = Promise.map(fooThenArrThen, (item: Foo, index: number, arrayLength:
 
 // fooArrThen
 
-barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
-barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo) => {
 	return barThen;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, {
 	concurrency: 1
@@ -1028,35 +1036,35 @@ barArrProm = Promise.map(fooArrThen, (item: Foo, index: number, arrayLength: num
 
 // fooThenArr
 
-barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
-barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo) => {
 	return barThen;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, {
 	concurrency: 1
@@ -1066,35 +1074,35 @@ barArrProm = Promise.map(fooThenArr, (item: Foo, index: number, arrayLength: num
 
 // fooArr
 
-barArrProm = Promise.map(fooArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.map(fooArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
-barArrProm = Promise.map(fooArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArr, (item: Foo) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo) => {
 	return barThen;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 }, {
 	concurrency: 1
 });
-barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.map(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, {
 	concurrency: 1
@@ -1108,16 +1116,16 @@ barArrProm = Promise.map(fooArr, (item: Foo, index: number, arrayLength: number)
 
 // fooThenArrThen
 
-barArrProm = Promise.mapSeries(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooThenArrThen, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
@@ -1125,16 +1133,16 @@ barArrProm = Promise.mapSeries(fooThenArrThen, (item: Foo, index: number, arrayL
 
 // fooArrThen
 
-barArrProm = Promise.mapSeries(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooArrThen, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
@@ -1142,16 +1150,16 @@ barArrProm = Promise.mapSeries(fooArrThen, (item: Foo, index: number, arrayLengt
 
 // fooThenArr
 
-barArrProm = Promise.mapSeries(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooThenArr, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
@@ -1159,16 +1167,16 @@ barArrProm = Promise.mapSeries(fooThenArr, (item: Foo, index: number, arrayLengt
 
 // fooArr
 
-barArrProm = Promise.mapSeries(fooArr, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooArr, (item: Foo) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooArr, (item: Foo) => {
+barArrProm = Bluebird.mapSeries(fooArr, (item: Foo) => {
 	return barThen;
 });
-barArrProm = Promise.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return bar;
 });
-barArrProm = Promise.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
+barArrProm = Bluebird.mapSeries(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 });
 
@@ -1180,16 +1188,16 @@ barArrProm = Promise.mapSeries(fooArr, (item: Foo, index: number, arrayLength: n
 
 // fooThenArrThen
 
-barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo) => {
 	return barThen;
 }, bar);
-barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, bar);
 
@@ -1197,16 +1205,16 @@ barProm = Promise.reduce(fooThenArrThen, (memo: Bar, item: Foo, index: number, a
 
 // fooArrThen
 
-barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo) => {
 	return barThen;
 }, bar);
-barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, bar);
 
@@ -1214,16 +1222,16 @@ barProm = Promise.reduce(fooArrThen, (memo: Bar, item: Foo, index: number, array
 
 // fooThenArr
 
-barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo) => {
 	return barThen;
 }, bar);
-barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, bar);
 
@@ -1231,16 +1239,16 @@ barProm = Promise.reduce(fooThenArr, (memo: Bar, item: Foo, index: number, array
 
 // fooArr
 
-barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo) => {
+barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo) => {
 	return barThen;
 }, bar);
-barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return memo;
 }, bar);
-barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
+barProm = Bluebird.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLength: number) => {
 	return barThen;
 }, bar);
 
@@ -1252,35 +1260,35 @@ barProm = Promise.reduce(fooArr, (memo: Bar, item: Foo, index: number, arrayLeng
 
 // fooThenArrThen
 
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
 	return boolThen;
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 });
 
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo) => {
 	return boolThen;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 }, {
 	concurrency: 1
@@ -1290,35 +1298,35 @@ fooArrProm = Promise.filter(fooThenArrThen, (item: Foo, index: number, arrayLeng
 
 // fooArrThen
 
-fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
 	return boolThen;
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 });
 
-fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo) => {
 	return boolThen;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArrThen, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 }, {
 	concurrency: 1
@@ -1328,35 +1336,35 @@ fooArrProm = Promise.filter(fooArrThen, (item: Foo, index: number, arrayLength:
 
 // fooThenArr
 
-fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
 	return boolThen;
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 });
 
-fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo) => {
 	return boolThen;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooThenArr, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 }, {
 	concurrency: 1
@@ -1366,35 +1374,35 @@ fooArrProm = Promise.filter(fooThenArr, (item: Foo, index: number, arrayLength:
 
 // fooArr
 
-fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
 	return boolThen;
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 });
 
-fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo) => {
 	return boolThen;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return bool;
 }, {
 	concurrency: 1
 });
-fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
+fooArrProm = Bluebird.filter(fooArr, (item: Foo, index: number, arrayLength: number) => {
 	return boolThen;
 }, {
 	concurrency: 1
@@ -1408,36 +1416,36 @@ fooArrProm = Promise.filter(fooArr, (item: Foo, index: number, arrayLength: numb
 
 // fooThenArrThen
 
-fooArrThen = Promise.each(fooThenArrThen, (item: Foo) => bar);
-fooArrThen = Promise.each(fooThenArrThen, (item: Foo) => barThen);
-fooArrThen = Promise.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => bar);
-fooArrThen = Promise.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
+fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo) => bar);
+fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo) => barThen);
+fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => bar);
+fooArrThen = Bluebird.each(fooThenArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // fooArrThen
 
-fooArrThen = Promise.each(fooArrThen, (item: Foo) => bar);
-fooArrThen = Promise.each(fooArrThen, (item: Foo) => barThen);
-fooArrThen = Promise.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => bar);
-fooArrThen = Promise.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
+fooArrThen = Bluebird.each(fooArrThen, (item: Foo) => bar);
+fooArrThen = Bluebird.each(fooArrThen, (item: Foo) => barThen);
+fooArrThen = Bluebird.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => bar);
+fooArrThen = Bluebird.each(fooArrThen, (item: Foo, index: number, arrayLength: number) => barThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // fooThenArr
 
-fooArrThen = Promise.each(fooThenArr, (item: Foo) => bar);
-fooArrThen = Promise.each(fooThenArr, (item: Foo) => barThen);
-fooArrThen = Promise.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => bar);
-fooArrThen = Promise.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => barThen);
+fooArrThen = Bluebird.each(fooThenArr, (item: Foo) => bar);
+fooArrThen = Bluebird.each(fooThenArr, (item: Foo) => barThen);
+fooArrThen = Bluebird.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => bar);
+fooArrThen = Bluebird.each(fooThenArr, (item: Foo, index: number, arrayLength: number) => barThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
 // fooArr
 
-fooArrThen = Promise.each(fooArr, (item: Foo) => bar);
-fooArrThen = Promise.each(fooArr, (item: Foo) => barThen);
-fooArrThen = Promise.each(fooArr, (item: Foo, index: number, arrayLength: number) => bar);
-fooArrThen = Promise.each(fooArr, (item: Foo, index: number, arrayLength: number) => barThen);
+fooArrThen = Bluebird.each(fooArr, (item: Foo) => bar);
+fooArrThen = Bluebird.each(fooArr, (item: Foo) => barThen);
+fooArrThen = Bluebird.each(fooArr, (item: Foo, index: number, arrayLength: number) => bar);
+fooArrThen = Bluebird.each(fooArr, (item: Foo, index: number, arrayLength: number) => barThen);
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/types/bluebird/index.d.ts b/types/bluebird/index.d.ts
index 13a11c2e3e3574a..7b3f6970bdec6ed 100644
--- a/types/bluebird/index.d.ts
+++ b/types/bluebird/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/petkaantonov/bluebird
 // Definitions by: Leonard Hecker <https://github.com/lhecker>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /*!
  * The code following this comment originates from:
@@ -41,6 +41,8 @@ type Resolvable<R> = R | PromiseLike<R>;
 type IterateFunction<T, R> = (item: T, index: number, arrayLength: number) => Resolvable<R>;
 
 declare class Bluebird<R> implements PromiseLike<R>, Bluebird.Inspection<R> {
+  readonly [Symbol.toStringTag]: "Object";
+
   /**
    * Create a new promise. The passed in function will receive functions
    * `resolve` and `reject` as its arguments which can be called to seal the fate of the created promise.
diff --git a/types/bookshelf/index.d.ts b/types/bookshelf/index.d.ts
index 2edb26987598e49..4bf14bf18939ab2 100644
--- a/types/bookshelf/index.d.ts
+++ b/types/bookshelf/index.d.ts
@@ -2,7 +2,7 @@
 // Project: http://bookshelfjs.org/
 // Definitions by: Andrew Schurman <https://github.com/arcticwaters>, Vesa Poikajärvi <https://github.com/vesse>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import Knex = require('knex');
 import knex = require('knex');
diff --git a/types/consolidate/index.d.ts b/types/consolidate/index.d.ts
index 23f431d8f8b6718..fbda61dd19c1937 100644
--- a/types/consolidate/index.d.ts
+++ b/types/consolidate/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/visionmedia/consolidate.js
 // Definitions by: Carlos Ballesteros Velasco <https://github.com/soywiz>, Theo Sherry <https://github.com/theosherry>, Nicolas Henry <https://github.com/nicolashenry>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 // Imported from: https://github.com/soywiz/typescript-node-definitions/consolidate.d.ts
 
diff --git a/types/db-migrate-base/index.d.ts b/types/db-migrate-base/index.d.ts
index c1c9189a50ca073..d7e0b6e4c863494 100644
--- a/types/db-migrate-base/index.d.ts
+++ b/types/db-migrate-base/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/db-migrate/db-migrate-base
 // Definitions by: nickiannone <https://github.com/nickiannone>
 // Definitions: https://github.com/nickiannone/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node"/>
 
diff --git a/types/db-migrate-pg/index.d.ts b/types/db-migrate-pg/index.d.ts
index 71726463e48152b..479a93aa45123ce 100644
--- a/types/db-migrate-pg/index.d.ts
+++ b/types/db-migrate-pg/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/db-migrate/pg
 // Definitions by: nickiannone <https://github.com/nickiannone>
 // Definitions: https://github.com/nickiannone/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as pg from "pg";
 import * as DbMigrateBase from "db-migrate-base";
diff --git a/types/dts-generator/index.d.ts b/types/dts-generator/index.d.ts
index d4d730850c4fbeb..fcf5412efcb0b76 100644
--- a/types/dts-generator/index.d.ts
+++ b/types/dts-generator/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/SitePen/dts-generator#readme
 // Definitions by: Matt Traynham <https://github.com/mtraynham>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import ts = require('typescript');
 import Bluebird = require('bluebird');
diff --git a/types/epilogue/index.d.ts b/types/epilogue/index.d.ts
index e54f127d9e87705..255dfa3e65a1e9c 100644
--- a/types/epilogue/index.d.ts
+++ b/types/epilogue/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/dchester/epilogue
 // Definitions by: Satana Charuwichitratana <https://github.com/micksatana>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import {
     Sequelize,
diff --git a/types/fs-extra-promise/index.d.ts b/types/fs-extra-promise/index.d.ts
index c2c12f6d28e3f39..98a6457af0fce86 100644
--- a/types/fs-extra-promise/index.d.ts
+++ b/types/fs-extra-promise/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/overlookmotel/fs-extra-promise
 // Definitions by: midknight41 <https://github.com/midknight41>, Jason Swearingen <https://github.com/jasonswearingen>, Hiromi Shikata <https://github.com/HiromiShikata>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/hexo-fs/index.d.ts b/types/hexo-fs/index.d.ts
index 6fc510b9a1ad48f..6c6e01860b8c09c 100644
--- a/types/hexo-fs/index.d.ts
+++ b/types/hexo-fs/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://hexo.io
 // Definitions by: segayuu <https://github.com/segayuu>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import Promise = require('bluebird');
 import {
diff --git a/types/inline-css/index.d.ts b/types/inline-css/index.d.ts
index 2567e01e85fdbe4..2cd05b79e00fb2a 100644
--- a/types/inline-css/index.d.ts
+++ b/types/inline-css/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/jonkemp/inline-css
 // Definitions by: Philip Spain <https://github.com/philipisapain>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import Promise = require('bluebird');
 
diff --git a/types/ioredis/v3/index.d.ts b/types/ioredis/v3/index.d.ts
index b346f7cee310d7e..3e21d8ef90c0ea8 100644
--- a/types/ioredis/v3/index.d.ts
+++ b/types/ioredis/v3/index.d.ts
@@ -9,7 +9,7 @@
 //                 Francis Gulotta <https://github.com/reconbot>
 //                 Alex Petty <https://github.com/pettyalex>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /* =================== USAGE ===================
     import * as Redis from "ioredis";
diff --git a/types/jackrabbit/index.d.ts b/types/jackrabbit/index.d.ts
index 7be4ee23ed74568..d86a8490388de0f 100644
--- a/types/jackrabbit/index.d.ts
+++ b/types/jackrabbit/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/hunterloftis/jackrabbit
 // Definitions by: Elvis Adomnica <https://github.com/elvisvoer>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import { Connection, Options, Message } from 'amqplib';
 
diff --git a/types/karma-coverage/index.d.ts b/types/karma-coverage/index.d.ts
index 8382ec7b124021f..3db557214262c5b 100644
--- a/types/karma-coverage/index.d.ts
+++ b/types/karma-coverage/index.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 //                 Yaroslav Admin <https://github.com/devoto13>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import 'karma';
 import * as istanbul from 'istanbul';
diff --git a/types/karma-webpack/index.d.ts b/types/karma-webpack/index.d.ts
index e3a1f5fceab9ee4..9ce8dd71b863233 100644
--- a/types/karma-webpack/index.d.ts
+++ b/types/karma-webpack/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/webpack-contrib/karma-webpack
 // Definitions by: Matt Traynham <https://github.com/mtraynham>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import 'karma';
 import * as Webpack from 'webpack';
diff --git a/types/karma/index.d.ts b/types/karma/index.d.ts
index 07146aeef505e48..51ceca3e4b5f74b 100644
--- a/types/karma/index.d.ts
+++ b/types/karma/index.d.ts
@@ -4,7 +4,7 @@
 //                 James Garbutt <https://github.com/43081j>
 //                 Yaroslav Admin <https://github.com/devoto13>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/karma/v1/index.d.ts b/types/karma/v1/index.d.ts
index 4b71c0a723be3a2..d61f1a330bfe8b8 100644
--- a/types/karma/v1/index.d.ts
+++ b/types/karma/v1/index.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 //                 James Garbutt <https://github.com/43081j>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/move-concurrently/index.d.ts b/types/move-concurrently/index.d.ts
index 75434a422489b77..5a8852c102b852e 100644
--- a/types/move-concurrently/index.d.ts
+++ b/types/move-concurrently/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://www.npmjs.com/package/move-concurrently
 // Definitions by: Melvin Groenhoff <https://github.com/mgroenhoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /**
  * Recursively moves from to to and resolves its promise when finished. If to already exists then the promise will be rejected with an EEXIST error.
diff --git a/types/node-mysql-wrapper/index.d.ts b/types/node-mysql-wrapper/index.d.ts
index 82170b4704cd018..37b7cd0885dbe6a 100644
--- a/types/node-mysql-wrapper/index.d.ts
+++ b/types/node-mysql-wrapper/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/nodets/node-mysql-wrapper
 // Definitions by: Makis Maropoulos <https://github.com/kataras>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 ///<reference path="./my-meteor.d.ts" />
 
diff --git a/types/orientjs/index.d.ts b/types/orientjs/index.d.ts
index 8e132a9fb854047..04b9a45b0b59da2 100644
--- a/types/orientjs/index.d.ts
+++ b/types/orientjs/index.d.ts
@@ -2,8 +2,8 @@
 // Project: https://github.com/orientechnologies/orientjs
 // Definitions by: [Saeed Tabrizi] <https://github.com/saeedtabrizi>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
-// Last Update  : 11-4-2019
+// TypeScript Version: 3.2
+// Last Update  : 17-4-2019
 // Compatible with Orientdb >= 2.2.x and orientjs <= 3.0.x features.
 // Developed with love in www.nowcando.com
 
diff --git a/types/project-oxford/index.d.ts b/types/project-oxford/index.d.ts
index 83c73da3f72bd8a..2781943942d799e 100644
--- a/types/project-oxford/index.d.ts
+++ b/types/project-oxford/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/felixrieseberg/project-oxford
 // Definitions by: Scott Southwood <https://github.com/scsouthw>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/promise-ftp/index.d.ts b/types/promise-ftp/index.d.ts
index 23aa5333e0c4b90..a949e3886c21d5b 100644
--- a/types/promise-ftp/index.d.ts
+++ b/types/promise-ftp/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/realtymaps/promise-ftp
 // Definitions by: coolreader18 <https://github.com/coolreader18>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/promise-sftp/index.d.ts b/types/promise-sftp/index.d.ts
index fc75bd9bee500c7..b434c37f92f06d8 100644
--- a/types/promise-sftp/index.d.ts
+++ b/types/promise-sftp/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/realtymaps/promise-sftp
 // Definitions by: coolreader18 <https://github.com/coolreader18>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />
 
diff --git a/types/redlock/index.d.ts b/types/redlock/index.d.ts
index 9b3af6d0b7dd5ad..2f211ad5a089b11 100644
--- a/types/redlock/index.d.ts
+++ b/types/redlock/index.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: Ilya Mochalov <https://github.com/chrootsu>
 //                 BendingBender <https://github.com/BendingBender>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as Promise from 'bluebird';
 import { EventEmitter } from 'events';
diff --git a/types/redlock/v2/index.d.ts b/types/redlock/v2/index.d.ts
index 9ca431c449d5b88..7851a2391a94de2 100644
--- a/types/redlock/v2/index.d.ts
+++ b/types/redlock/v2/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/mike-marcacci/node-redlock
 // Definitions by: Ilya Mochalov <https://github.com/chrootsu>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as redis from 'redis';
 import * as Promise from 'bluebird';
diff --git a/types/request-promise/index.d.ts b/types/request-promise/index.d.ts
index 7cfb0a26088ef6a..83c4d3022e532a0 100644
--- a/types/request-promise/index.d.ts
+++ b/types/request-promise/index.d.ts
@@ -5,7 +5,7 @@
 //                 Aya Morisawa <https://github.com/AyaMorisawa>
 //                 Matt R. Wilson <https://github.com/mastermatt>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import request = require('request');
 import http = require('http');
diff --git a/types/restling/index.d.ts b/types/restling/index.d.ts
index b4f03a663376f0e..094e59a4a9c8f59 100644
--- a/types/restling/index.d.ts
+++ b/types/restling/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/lucasfeliciano/restling
 // Definitions by: Alessandro vergani <https://github.com/loghorn>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as Promise from "bluebird";
 import * as Restler from "restler";
diff --git a/types/retry-as-promised/index.d.ts b/types/retry-as-promised/index.d.ts
index 6287827defe13ea..5382db9f0108433 100644
--- a/types/retry-as-promised/index.d.ts
+++ b/types/retry-as-promised/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/mickhansen/retry-as-promised
 // Definitions by: Florian Oellerich <https://github.com/Raigen>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import Promise = require('bluebird');
 
diff --git a/types/sequelize-cursor-pagination/index.d.ts b/types/sequelize-cursor-pagination/index.d.ts
index 09c3d1b653055bf..7efc1f4442d9a7f 100644
--- a/types/sequelize-cursor-pagination/index.d.ts
+++ b/types/sequelize-cursor-pagination/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/Kaltsoon/sequelize-cursor-pagination
 // Definitions by: pilagod <https://github.com/pilagod>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped/
-// TypeScript Version: 2.9
+// TypeScript Version: 3.2
 
 import Sequelize = require('sequelize');
 
diff --git a/types/sequelize-fixtures/index.d.ts b/types/sequelize-fixtures/index.d.ts
index 773bb43982e7f90..694f12db6084d89 100644
--- a/types/sequelize-fixtures/index.d.ts
+++ b/types/sequelize-fixtures/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/domasx2/sequelize-fixtures
 // Definitions by: Christian Schwarz <https://github.com/cschwarz>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as Sequelize from "sequelize";
 
diff --git a/types/sequelize/index.d.ts b/types/sequelize/index.d.ts
index 897d9e48609a8ac..b15fe2790cbff2a 100644
--- a/types/sequelize/index.d.ts
+++ b/types/sequelize/index.d.ts
@@ -20,7 +20,7 @@
 //                 Emmanuel Gautier <https://github.com/emmanuelgautier>
 //                 Dan Rumney <https://github.com/dancrumb>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 // ***************************** IMPORTANT NOTE *****************************
 // These types are for the 4.x branch of Sequelize. As of Sequelize 5.0,
diff --git a/types/sequelize/v3/index.d.ts b/types/sequelize/v3/index.d.ts
index 6acc528bc02aad4..66ef8864f9ce2e2 100644
--- a/types/sequelize/v3/index.d.ts
+++ b/types/sequelize/v3/index.d.ts
@@ -6,7 +6,7 @@
 //                 Nick Mueller <https://github.com/morpheusxaut>
 //                 James D. Callahan III <https://github.com/torhal>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 // Based on original work by: samuelneff <https://github.com/samuelneff/sequelize-auto-ts/blob/master/lib/sequelize.d.ts>
 
diff --git a/types/simple-oauth2/v1/index.d.ts b/types/simple-oauth2/v1/index.d.ts
index 30b1a72d98d8e5e..c1ac8b9444627ca 100644
--- a/types/simple-oauth2/v1/index.d.ts
+++ b/types/simple-oauth2/v1/index.d.ts
@@ -4,7 +4,7 @@
 //                 Troy Lamerton <https://github.com/troy-lamerton>
 //                 Martín Rodriguez <https://github.com/netux>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.9
+// TypeScript Version: 3.2
 
 import Bluebird = require("bluebird");
 
diff --git a/types/supertest-as-promised/index.d.ts b/types/supertest-as-promised/index.d.ts
index 18047870a7b4481..a28449ec7a8972f 100644
--- a/types/supertest-as-promised/index.d.ts
+++ b/types/supertest-as-promised/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/WhoopInc/supertest-as-promised
 // Definitions by: Tanguy Krotoff <https://github.com/tkrotoff>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import * as supertest from "supertest";
 import * as superagent from "superagent";
diff --git a/types/umzug/index.d.ts b/types/umzug/index.d.ts
index e7d761ab3c6cc50..91b01695c59254e 100644
--- a/types/umzug/index.d.ts
+++ b/types/umzug/index.d.ts
@@ -5,7 +5,7 @@
 //                 Troy McKinnon <https://github.com/trodi>
 //                 Emmanuel Gautier <https://github.com/emmanuelgautier>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 import { EventEmitter } from 'events';
 import Sequelize = require("sequelize");
diff --git a/types/waterline/index.d.ts b/types/waterline/index.d.ts
index b0a23d8e5a40f32..1e2059477e5eafe 100644
--- a/types/waterline/index.d.ts
+++ b/types/waterline/index.d.ts
@@ -2,7 +2,7 @@
 // Project: https://github.com/balderdashy/waterline
 // Definitions by: Alexandro Libertino <https://github.com/arvitaly>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.8
+// TypeScript Version: 3.2
 
 /// <reference types="node" />