diff --git a/modules/-all/index.ts b/modules/-all/index.ts
index 8cd6e24..8d612d2 100644
--- a/modules/-all/index.ts
+++ b/modules/-all/index.ts
@@ -24,13 +24,13 @@ export { default as mapParallel } from '@promises/map-parallel';
 export { default as mapSeries } from '@promises/map-series';
 export { default as next } from '@promises/next';
 export { default as parallel } from '@promises/parallel';
-export { default as promisify, PromisifyOptions } from '@promises/promisify';
+export { default as promisify, IPromisifyOptions } from '@promises/promisify';
 export { default as reduceSeries } from '@promises/reduce-series';
 export { default as reduceRightSeries } from '@promises/reduce-right-series';
 export { default as rejectParallel } from '@promises/reject-parallel';
 export { default as rejectSeries } from '@promises/reject-series';
 export { default as reset } from '@promises/reset';
-export { default as retry, RetryOptions, RetryFilterInfo, RetryTimeInfo } from '@promises/retry';
+export { default as retry, IRetryOptions, IRetryFilterInfo, IRetryTimeInfo } from '@promises/retry';
 export { default as series } from '@promises/series';
 export { default as sleep } from '@promises/sleep';
 export { default as someParallel } from '@promises/some-parallel';
diff --git a/modules/-constructor/index.ts b/modules/-constructor/index.ts
index 6550cd1..ec6ae64 100644
--- a/modules/-constructor/index.ts
+++ b/modules/-constructor/index.ts
@@ -10,7 +10,7 @@ export { default as create } from '@promises/create';
 export { default as delay } from '@promises/delay';
 export { default as exec } from '@promises/exec';
 export { default as isPromise } from '@promises/is-promise';
-export { default as promisify, PromisifyOptions } from '@promises/promisify';
+export { default as promisify, IPromisifyOptions } from '@promises/promisify';
 export { default as parallel } from '@promises/parallel';
 export { default as series } from '@promises/series';
 export { default as timeout } from '@promises/timeout';
diff --git a/modules/-prototype/index.ts b/modules/-prototype/index.ts
index 766a591..eb24e01 100644
--- a/modules/-prototype/index.ts
+++ b/modules/-prototype/index.ts
@@ -23,7 +23,7 @@ export { default as reduceRightSeries } from '@promises/reduce-right-series';
 export { default as rejectParallel } from '@promises/reject-parallel';
 export { default as rejectSeries } from '@promises/reject-series';
 export { default as reset } from '@promises/reset';
-export { default as retry, RetryOptions, RetryFilterInfo, RetryTimeInfo } from '@promises/retry';
+export { default as retry, IRetryOptions, IRetryFilterInfo, IRetryTimeInfo } from '@promises/retry';
 export { default as sleep } from '@promises/sleep';
 export { default as someParallel } from '@promises/some-parallel';
 export { default as someSeries } from '@promises/some-series';
diff --git a/modules/compose/index.ts b/modules/compose/index.ts
index 02eb51a..c9fda6a 100644
--- a/modules/compose/index.ts
+++ b/modules/compose/index.ts
@@ -6,7 +6,7 @@
 
 import Promises from '@promises/core';
 import reduce from '@promises/reduce-series';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -21,15 +21,15 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function composeStatic<T, P1, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, P5, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<P5>, fn6: (value: OptionalPromise<P5>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, P5, P6, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<P5>, fn6: (value: OptionalPromise<P5>) => OptionalPromise<P6>, fn7: (value: OptionalPromise<P6>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<P5>, fn6: (value: OptionalPromise<P5>) => OptionalPromise<P6>, fn7: (value: OptionalPromise<P6>) => OptionalPromise<P7>, fn8: (value: OptionalPromise<P7>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, P8, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<P5>, fn6: (value: OptionalPromise<P5>) => OptionalPromise<P6>, fn7: (value: OptionalPromise<P6>) => OptionalPromise<P7>, fn8: (value: OptionalPromise<P7>) => OptionalPromise<P8>, fn9: (value: OptionalPromise<P8>) => OptionalPromise<R>): (value?: T) => Promises<R>;
-function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn1: (value?: OptionalPromise<T>) => OptionalPromise<P1>, fn2: (value: OptionalPromise<P1>) => OptionalPromise<P2>, fn3: (value: OptionalPromise<P2>) => OptionalPromise<P3>, fn4: (value: OptionalPromise<P3>) => OptionalPromise<P4>, fn5: (value: OptionalPromise<P4>) => OptionalPromise<P5>, fn6: (value: OptionalPromise<P5>) => OptionalPromise<P6>, fn7: (value: OptionalPromise<P6>) => OptionalPromise<P7>, fn8: (value: OptionalPromise<P7>) => OptionalPromise<P8>, fn9: (value: OptionalPromise<P8>) => OptionalPromise<P9>, fn10: (value: OptionalPromise<P9>) => OptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, P5, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<P5>, fn6: (value: IOptionalPromise<P5>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, P5, P6, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<P5>, fn6: (value: IOptionalPromise<P5>) => IOptionalPromise<P6>, fn7: (value: IOptionalPromise<P6>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<P5>, fn6: (value: IOptionalPromise<P5>) => IOptionalPromise<P6>, fn7: (value: IOptionalPromise<P6>) => IOptionalPromise<P7>, fn8: (value: IOptionalPromise<P7>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, P8, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<P5>, fn6: (value: IOptionalPromise<P5>) => IOptionalPromise<P6>, fn7: (value: IOptionalPromise<P6>) => IOptionalPromise<P7>, fn8: (value: IOptionalPromise<P7>) => IOptionalPromise<P8>, fn9: (value: IOptionalPromise<P8>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
+function composeStatic<T, P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn1: (value?: IOptionalPromise<T>) => IOptionalPromise<P1>, fn2: (value: IOptionalPromise<P1>) => IOptionalPromise<P2>, fn3: (value: IOptionalPromise<P2>) => IOptionalPromise<P3>, fn4: (value: IOptionalPromise<P3>) => IOptionalPromise<P4>, fn5: (value: IOptionalPromise<P4>) => IOptionalPromise<P5>, fn6: (value: IOptionalPromise<P5>) => IOptionalPromise<P6>, fn7: (value: IOptionalPromise<P6>) => IOptionalPromise<P7>, fn8: (value: IOptionalPromise<P7>) => IOptionalPromise<P8>, fn9: (value: IOptionalPromise<P8>) => IOptionalPromise<P9>, fn10: (value: IOptionalPromise<P9>) => IOptionalPromise<R>): (value?: T) => Promises<R>;
 function composeStatic(...functions) {
     return (value) => {
         return reduce(functions, (value, fn) => {
diff --git a/modules/create/index.ts b/modules/create/index.ts
index 7695111..52fda5e 100644
--- a/modules/create/index.ts
+++ b/modules/create/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { IExecute } from '@promises/interfaces';
+import { IExecutor } from '@promises/interfaces';
 
 /**
  * @example
@@ -20,8 +20,8 @@ import { IExecute } from '@promises/interfaces';
  *  });
  * ```
  */
-function createStatic<T>(execute: IExecute<T> = (resolve) => resolve()): Promises<T> {
-    return new Promises(execute);
+function createStatic<T>(executor: IExecutor<T> = (resolve) => resolve()): Promises<T> {
+    return new Promises(executor);
 }
 
 export default createStatic;
diff --git a/modules/error/index.ts b/modules/error/index.ts
index d17ca25..d6c1b96 100644
--- a/modules/error/index.ts
+++ b/modules/error/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -25,7 +25,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function error(promises: OptionalPromise<any>, value: any): Promises<any> {
+function error(promises: IOptionalPromise<any>, value: any): Promises<any> {
     return Promises.resolve(promises).then(() => {
         throw value;
     }) as Promises<any>;
diff --git a/modules/exec/index.ts b/modules/exec/index.ts
index dda71f4..8b95225 100644
--- a/modules/exec/index.ts
+++ b/modules/exec/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -20,7 +20,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function execStatic<R>(fn: () => OptionalPromise<R>): Promises<R> {
+function execStatic<R>(fn: () => IOptionalPromise<R>): Promises<R> {
     return Promises.resolve().then(fn) as Promises<R>;
 }
 
diff --git a/modules/finally/index.ts b/modules/finally/index.ts
index aff6c2a..c741233 100644
--- a/modules/finally/index.ts
+++ b/modules/finally/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -25,7 +25,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function _finally<R>(promise: OptionalPromise<any>, fn: () => OptionalPromise<any>): Promises<R> {
+function _finally<R>(promise: IOptionalPromise<any>, fn: () => IOptionalPromise<any>): Promises<R> {
     let onBoth = (value) => {
         let result = fn();
         return Promise.resolve(result).then(() => value);
@@ -57,6 +57,6 @@ declare module '@promises/core' {
          *  });
          * ```
          */
-        finally(this: Promises<T>, fn: () => OptionalPromise<any>): Promises<T>;
+        finally(this: Promises<T>, fn: () => IOptionalPromise<any>): Promises<T>;
     }
 }
diff --git a/modules/interfaces/index.ts b/modules/interfaces/index.ts
index 1702d58..51f436c 100644
--- a/modules/interfaces/index.ts
+++ b/modules/interfaces/index.ts
@@ -6,66 +6,66 @@
 
 import Promises from '@promises/core';
 
-export type Dictionary<T> = { [key: string]: T };
-export type OptionalPromise<T> = PromiseLike<T> | T;
-export type OptionalPromiseArray<T> = OptionalPromise<OptionalPromise<ArrayLike<T[keyof T & number]>>>;
-export type OptionalPromiseDictionary<T> = OptionalPromise<OptionalPromise<Dictionary<T[keyof T]>>>;
-export type IExecute<T> = (resolve?: (value?: T) => void, reject?: (reason?: any) => void) => void;
+export type IDictionary<T> = { [key: string]: T };
+export type IOptionalPromise<T> = PromiseLike<T> | T;
+export type IOptionalPromiseArray<T> = IOptionalPromise<IOptionalPromise<ArrayLike<T[keyof T & number]>>>;
+export type IOptionalPromiseDictionary<T> = IOptionalPromise<IOptionalPromise<IDictionary<T[keyof T]>>>;
+export type IExecutor<T> = (resolve?: (value?: T) => void, reject?: (reason?: any) => void) => void;
 
 export interface IForEach {
-    <T extends ArrayLike<any>>(str: OptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<any>): Promises<T>;
-    <T>(object: OptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<any>): Promises<T>;
+    <T extends ArrayLike<any>>(str: IOptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<any>): Promises<T>;
+    <T>(object: IOptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<any>): Promises<T>;
 }
 
 export interface IForEachWrapper<T> {
-    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, array: T) => OptionalPromise<any>): Promises<T>;
-    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<any>): Promises<T>;
+    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, array: T) => IOptionalPromise<any>): Promises<T>;
+    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<any>): Promises<T>;
 }
 
 export interface IMap {
-     <T extends ArrayLike<any>>(array: OptionalPromiseArray<T>, iteratee?: (value: T[keyof T & number], index: number, array: T) => OptionalPromise<T[keyof T & number]>): Promises<T>;
-    <T extends ArrayLike<any>, R>(array: OptionalPromiseArray<T>, iteratee?: (value: T[keyof T & number], index: number, array: T) => OptionalPromise<R>): Promises<R[]>;
-    <T>(object: OptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<T[keyof T]>): Promises<T>;
-    <T, R>(object: OptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<R>): Promises<Dictionary<R>>;
+     <T extends ArrayLike<any>>(array: IOptionalPromiseArray<T>, iteratee?: (value: T[keyof T & number], index: number, array: T) => IOptionalPromise<T[keyof T & number]>): Promises<T>;
+    <T extends ArrayLike<any>, R>(array: IOptionalPromiseArray<T>, iteratee?: (value: T[keyof T & number], index: number, array: T) => IOptionalPromise<R>): Promises<R[]>;
+    <T>(object: IOptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<T[keyof T]>): Promises<T>;
+    <T, R>(object: IOptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<R>): Promises<IDictionary<R>>;
 }
 
 export interface IMapWrapper<T> {
-    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<T[keyof T & number]>): Promises<T>;
-    <R>(this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<R>): Promises<R[]>;
-    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<T[keyof T]>): Promises<T>;
-    <R>(this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<R>): Promises<Dictionary<R>>;
+    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<T[keyof T & number]>): Promises<T>;
+    <R>(this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<R>): Promises<R[]>;
+    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<T[keyof T]>): Promises<T>;
+    <R>(this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<R>): Promises<IDictionary<R>>;
 }
 
 export interface IChecksBoolean {
-    <T extends ArrayLike<any>>(str: OptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<boolean>): Promises<boolean>;
-    <T>(object: OptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<boolean>): Promises<boolean>;
+    <T extends ArrayLike<any>>(str: IOptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<boolean>): Promises<boolean>;
+    <T>(object: IOptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<boolean>): Promises<boolean>;
 }
 
 export interface IChecksBooleanWrapper<T> {
-    <T extends ArrayLike<any>>(this: Promises<T & string>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<boolean>): Promises<boolean>;
-    <T>(this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<boolean>): Promises<boolean>;
+    <T extends ArrayLike<any>>(this: Promises<T & string>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<boolean>): Promises<boolean>;
+    <T>(this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<boolean>): Promises<boolean>;
 }
 
 export interface IFilter {
-    <T extends ArrayLike<any>>(str: OptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<boolean>): Promises<T>;
-    <T>(object: OptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<boolean>): Promises<T>;
+    <T extends ArrayLike<any>>(str: IOptionalPromise<T>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<boolean>): Promises<T>;
+    <T>(object: IOptionalPromiseDictionary<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<boolean>): Promises<T>;
 }
 
 export interface IFilterWrapper<T> {
-    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => OptionalPromise<boolean>): Promises<T>;
-    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => OptionalPromise<boolean>): Promises<T>;
+    (this: Promises<T & ArrayLike<any>>, iteratee?: (value: T[keyof T & number], index: number, str: T) => IOptionalPromise<boolean>): Promises<T>;
+    (this: Promises<T>, iteratee?: (value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<boolean>): Promises<T>;
 }
 
 export interface IReduce {
-    <T extends ArrayLike<any>>(str: OptionalPromise<T>, iteratee?: (accumulator: T[keyof T & number], value: T[keyof T & number], index: number, str: T) => OptionalPromise<T[keyof T & number]>, accumulator?: T[keyof T & number]): Promises<T[keyof T & number]>;
-    <T extends ArrayLike<any>, R>(str: OptionalPromise<T>, iteratee?: (accumulator: R, value: T[keyof T & number], index: number, str: T) => OptionalPromise<R>, accumulator?: R): Promises<R>;
-    <T>(object: OptionalPromiseDictionary<T>, iteratee?: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, object: T) => OptionalPromise<T[keyof T]>, accumulator?: T[keyof T]): Promises<T[keyof T]>;
-    <T, R>(object: OptionalPromiseDictionary<T>, iteratee?: (accumulator: R, value: T[keyof T], key: keyof T, object: T) => OptionalPromise<R>, accumulator?: R): Promises<R>;
+    <T extends ArrayLike<any>>(str: IOptionalPromise<T>, iteratee?: (accumulator: T[keyof T & number], value: T[keyof T & number], index: number, str: T) => IOptionalPromise<T[keyof T & number]>, accumulator?: T[keyof T & number]): Promises<T[keyof T & number]>;
+    <T extends ArrayLike<any>, R>(str: IOptionalPromise<T>, iteratee?: (accumulator: R, value: T[keyof T & number], index: number, str: T) => IOptionalPromise<R>, accumulator?: R): Promises<R>;
+    <T>(object: IOptionalPromiseDictionary<T>, iteratee?: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<T[keyof T]>, accumulator?: T[keyof T]): Promises<T[keyof T]>;
+    <T, R>(object: IOptionalPromiseDictionary<T>, iteratee?: (accumulator: R, value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<R>, accumulator?: R): Promises<R>;
 }
 
 export interface IReduceWrapper<T> {
-    (this: Promises<T & ArrayLike<any>>, iteratee?: (accumulator: T[keyof T & number], value: T[keyof T & number], index: number, str: T) => OptionalPromise<T[keyof T & number]>, accumulator?: T[keyof T & number]): Promises<T[keyof T & number]>;
-    <R>(this: Promises<T & ArrayLike<any>>, iteratee?: (accumulator: R, value: T[keyof T & number], index: number, str: T) => OptionalPromise<R>, accumulator?: R): Promises<R>;
-   (this: Promises<T>, iteratee?: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, object: T) => OptionalPromise<T[keyof T]>, accumulator?: T[keyof T]): Promises<T[keyof T]>;
-    <R>(this: Promises<T>, iteratee?: (accumulator: R, value: T[keyof T], key: keyof T, object: T) => OptionalPromise<R>, accumulator?: R): Promises<R>;
+    (this: Promises<T & ArrayLike<any>>, iteratee?: (accumulator: T[keyof T & number], value: T[keyof T & number], index: number, str: T) => IOptionalPromise<T[keyof T & number]>, accumulator?: T[keyof T & number]): Promises<T[keyof T & number]>;
+    <R>(this: Promises<T & ArrayLike<any>>, iteratee?: (accumulator: R, value: T[keyof T & number], index: number, str: T) => IOptionalPromise<R>, accumulator?: R): Promises<R>;
+   (this: Promises<T>, iteratee?: (accumulator: T[keyof T], value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<T[keyof T]>, accumulator?: T[keyof T]): Promises<T[keyof T]>;
+    <R>(this: Promises<T>, iteratee?: (accumulator: R, value: T[keyof T], key: keyof T, object: T) => IOptionalPromise<R>, accumulator?: R): Promises<R>;
 }
diff --git a/modules/keys/index.ts b/modules/keys/index.ts
index 50becac..cc442be 100644
--- a/modules/keys/index.ts
+++ b/modules/keys/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 import _keys from '@promises/_keys';
 
 /**
@@ -20,8 +20,8 @@ import _keys from '@promises/_keys';
  *  });
  * ```
  */
-function keys<T>(collection: OptionalPromise<T>): Promises<string[]>;
-function keys<T, R>(collection: OptionalPromise<T>, fn: (keys: string[]) => OptionalPromise<R>): Promises<R>;
+function keys<T>(collection: IOptionalPromise<T>): Promises<string[]>;
+function keys<T, R>(collection: IOptionalPromise<T>, fn: (keys: string[]) => IOptionalPromise<R>): Promises<R>;
 function keys(collection, fn = v => v) {
     let keys = _keys(collection);
     return Promises.resolve(keys).then(fn);
@@ -46,6 +46,6 @@ declare module '@promises/core' {
          * ```
          */
         keys(this: Promises<T>): Promises<string[]>;
-        keys<R>(this: Promises<T>, fn: (keys: string[]) => OptionalPromise<R>): Promises<R>;
+        keys<R>(this: Promises<T>, fn: (keys: string[]) => IOptionalPromise<R>): Promises<R>;
     }
 }
diff --git a/modules/next/index.ts b/modules/next/index.ts
index c940836..805c895 100644
--- a/modules/next/index.ts
+++ b/modules/next/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -25,7 +25,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function next<R>(promise: OptionalPromise<any>, value: OptionalPromise<R>): Promises<R> {
+function next<R>(promise: IOptionalPromise<any>, value: IOptionalPromise<R>): Promises<R> {
     return Promises.resolve(promise).then(() => {
         return value;
     }) as Promises<R>;
@@ -55,6 +55,6 @@ declare module '@promises/core' {
          *  });
          * ```
          */
-        next<R>(this: Promises<T>, value: OptionalPromise<R>): Promises<R>;
+        next<R>(this: Promises<T>, value: IOptionalPromise<R>): Promises<R>;
     }
 }
diff --git a/modules/parallel/index.ts b/modules/parallel/index.ts
index c530c69..ce659ff 100644
--- a/modules/parallel/index.ts
+++ b/modules/parallel/index.ts
@@ -6,7 +6,7 @@
 
 import Promises from '@promises/core';
 import map from '@promises/map-parallel';
-import { OptionalPromise, Dictionary } from '@promises/interfaces';
+import { IOptionalPromise, IDictionary } from '@promises/interfaces';
 
 /**
  * @example
@@ -32,10 +32,10 @@ import { OptionalPromise, Dictionary } from '@promises/interfaces';
  *  // => { zero: 0, one: 1, two: 2}
  * ```
  */
-function parallelStatic<R>(array: (() => OptionalPromise<R>)[]): Promises<R[]>;
-function parallelStatic<R extends ArrayLike<any>>(array: (() => OptionalPromise<R[keyof R & number]>)[]): Promises<R>;
-function parallelStatic<R>(object: Dictionary<(() => OptionalPromise<R>)>): Promises<Dictionary<R>>;
-function parallelStatic<R extends Dictionary<any>>(object: Dictionary<(() => OptionalPromise<R[keyof R]>)>): Promises<R>;
+function parallelStatic<R>(array: (() => IOptionalPromise<R>)[]): Promises<R[]>;
+function parallelStatic<R extends ArrayLike<any>>(array: (() => IOptionalPromise<R[keyof R & number]>)[]): Promises<R>;
+function parallelStatic<R>(object: IDictionary<(() => IOptionalPromise<R>)>): Promises<IDictionary<R>>;
+function parallelStatic<R extends IDictionary<any>>(object: IDictionary<(() => IOptionalPromise<R[keyof R]>)>): Promises<R>;
 function parallelStatic(functions) {
     return map(functions, (fn) => fn());
 }
diff --git a/modules/promisify/index.ts b/modules/promisify/index.ts
index 70d9745..1c58a37 100644
--- a/modules/promisify/index.ts
+++ b/modules/promisify/index.ts
@@ -5,9 +5,9 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
-export interface PromisifyOptions {
+export interface IPromisifyOptions {
     context?: any;
     multi?: boolean;
 }
@@ -29,28 +29,28 @@ export interface PromisifyOptions {
  * ```
  */
 function promisifyStatic<R>(fn: (cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): () => Promises<R>;
-function promisifyStatic<P1, R>(fn: (p1: P1, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>) => Promises<R>;
-function promisifyStatic<P1, P2, R>(fn: (p1: P1, p2: P2, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>, p10: OptionalPromise<P10>) => Promises<R>;
+function promisifyStatic<P1, R>(fn: (p1: P1, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>) => Promises<R>;
+function promisifyStatic<P1, P2, R>(fn: (p1: P1, p2: P2, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, cb: (error: any, ...result: R[keyof R & number][]) => void) => void, options: { multi: true, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>, p10: IOptionalPromise<P10>) => Promises<R>;
 function promisifyStatic<R>(fn: (cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): () => Promises<R>;
-function promisifyStatic<P1, R>(fn: (p1: P1, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>) => Promises<R>;
-function promisifyStatic<P1, P2, R>(fn: (p1: P1, p2: P2, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>) => Promises<R>;
-function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>, p10: OptionalPromise<P10>) => Promises<R>;
-function promisifyStatic(fn, {multi, context}: PromisifyOptions = {}) {
+function promisifyStatic<P1, R>(fn: (p1: P1, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>) => Promises<R>;
+function promisifyStatic<P1, P2, R>(fn: (p1: P1, p2: P2, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>) => Promises<R>;
+function promisifyStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10, cb: (error: any, result: R) => void) => void, options?: { multi?: false, context?: any }): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>, p10: IOptionalPromise<P10>) => Promises<R>;
+function promisifyStatic(fn, {multi, context}: IPromisifyOptions = {}) {
     return function (...args) {
         return Promises.all(args).then((args) => {
             return new Promises((resolve, reject) => {
diff --git a/modules/reset/index.ts b/modules/reset/index.ts
index fdebc17..9e26454 100644
--- a/modules/reset/index.ts
+++ b/modules/reset/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -25,7 +25,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function reset<R>(promise: OptionalPromise<any>, value: OptionalPromise<R>): Promises<R> {
+function reset<R>(promise: IOptionalPromise<any>, value: IOptionalPromise<R>): Promises<R> {
     return Promises.resolve(promise).then(() => value, () => value) as Promises<R>;
 }
 
@@ -53,6 +53,6 @@ declare module '@promises/core' {
          *  });
          * ```
          */
-        reset<R>(this: Promises<T>, value: OptionalPromise<R>): Promises<R>;
+        reset<R>(this: Promises<T>, value: IOptionalPromise<R>): Promises<R>;
     }
 }
diff --git a/modules/retry/index.ts b/modules/retry/index.ts
index b28a02a..28ad0a7 100644
--- a/modules/retry/index.ts
+++ b/modules/retry/index.ts
@@ -8,22 +8,22 @@ import Promises from '@promises/core';
 import exec from '@promises/exec';
 import timeout from '@promises/timeout';
 import '@promises/timer';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
-export interface RetryOptions {
+export interface IRetryOptions {
     times?: number;
-    interval?: number | ((info: RetryTimeInfo) => number);
-    timer?: number | ((info: RetryTimeInfo) => number);
-    filter?: (info: RetryFilterInfo) => boolean;
+    interval?: number | ((info: IRetryTimeInfo) => number);
+    timer?: number | ((info: IRetryTimeInfo) => number);
+    filter?: (info: IRetryFilterInfo) => boolean;
 }
 
-export interface RetryTimeInfo {
+export interface IRetryTimeInfo {
     counter: number;
     last: number;
     times: number;
 }
 
-export interface RetryFilterInfo {
+export interface IRetryFilterInfo {
     counter: number;
     error: any;
     times: number;
@@ -44,7 +44,7 @@ export interface RetryFilterInfo {
  *  })
  * ```
  */
-function retryStatic<R>(fn: () => OptionalPromise<R>, options?: RetryOptions): Promises<R> {
+function retryStatic<R>(fn: () => IOptionalPromise<R>, options?: IRetryOptions): Promises<R> {
     let { times = 1, interval, timer, filter = (error) => true } = options || {} as any;
     return retryHelper(fn, { times, interval, timer, filter, counter: 1 }) as Promises<R>;
 }
diff --git a/modules/series/index.ts b/modules/series/index.ts
index bd5f080..ba2556f 100644
--- a/modules/series/index.ts
+++ b/modules/series/index.ts
@@ -6,7 +6,7 @@
 
 import Promises from '@promises/core';
 import map from '@promises/map-series';
-import { OptionalPromise, Dictionary } from '@promises/interfaces';
+import { IOptionalPromise, IDictionary } from '@promises/interfaces';
 
 /**
  * @example
@@ -32,10 +32,10 @@ import { OptionalPromise, Dictionary } from '@promises/interfaces';
  *  // => ['zero', 'one', 'two']
  * ```
  */
-function seriesStatic<R>(array: (() => OptionalPromise<R>)[]): Promises<R[]>;
-function seriesStatic<R extends ArrayLike<any>>(array: (() => OptionalPromise<R[keyof R & number]>)[]): Promises<R>;
-function seriesStatic<R>(object: Dictionary<(() => OptionalPromise<R>)>): Promises<Dictionary<R>>;
-function seriesStatic<R extends Dictionary<any>>(object: Dictionary<(() => OptionalPromise<R[keyof R]>)>): Promises<R>;
+function seriesStatic<R>(array: (() => IOptionalPromise<R>)[]): Promises<R[]>;
+function seriesStatic<R extends ArrayLike<any>>(array: (() => IOptionalPromise<R[keyof R & number]>)[]): Promises<R>;
+function seriesStatic<R>(object: IDictionary<(() => IOptionalPromise<R>)>): Promises<IDictionary<R>>;
+function seriesStatic<R extends IDictionary<any>>(object: IDictionary<(() => IOptionalPromise<R[keyof R]>)>): Promises<R>;
 function seriesStatic(functions) {
     return map(functions, (fn) => fn());
 }
diff --git a/modules/sleep/index.ts b/modules/sleep/index.ts
index 2df16ab..0e00ea9 100644
--- a/modules/sleep/index.ts
+++ b/modules/sleep/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -17,7 +17,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  });
  * ```
  */
-function sleep<T>(value?: OptionalPromise<T>, ms?: number): Promises<T> {
+function sleep<T>(value?: IOptionalPromise<T>, ms?: number): Promises<T> {
     return Promises.resolve(value).then(() => new Promises<T>((resolve) => {
         setTimeout(() => resolve(value), ms);
     })) as Promises<T>;
diff --git a/modules/spread/index.ts b/modules/spread/index.ts
index 51fce66..24ca2af 100644
--- a/modules/spread/index.ts
+++ b/modules/spread/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise, OptionalPromiseArray } from '@promises/interfaces';
+import { IOptionalPromise, IOptionalPromiseArray } from '@promises/interfaces';
 
 /**
  * @example
@@ -19,8 +19,8 @@ import { OptionalPromise, OptionalPromiseArray } from '@promises/interfaces';
  *  });
  * ```
  */
-function spread<T extends ArrayLike<any>>(array: OptionalPromiseArray<T>, fn: (...args: (T[keyof T & number])[]) => OptionalPromise<T>): Promises<T>;
-function spread<T extends ArrayLike<any>, R>(array: OptionalPromiseArray<T>, fn: (...args: (T[keyof T & number])[]) => OptionalPromise<R>): Promises<R>;
+function spread<T extends ArrayLike<any>>(array: IOptionalPromiseArray<T>, fn: (...args: (T[keyof T & number])[]) => IOptionalPromise<T>): Promises<T>;
+function spread<T extends ArrayLike<any>, R>(array: IOptionalPromiseArray<T>, fn: (...args: (T[keyof T & number])[]) => IOptionalPromise<R>): Promises<R>;
 function spread(array, fn) {
     return (Promises as any).resolve(array).then((array) => {
         return Array.isArray(array) ? Promises.all(array) : Object(array);
@@ -47,7 +47,7 @@ declare module '@promises/core' {
          *  })
          * ```
          */
-        spread(this: Promises<T & ArrayLike<any>>, fn: (...args: (T[keyof T & number])[]) => OptionalPromise<T>): Promises<T>;
-        spread<R>(this: Promises<T & ArrayLike<any>>, fn: (...args: (T[keyof T & number])[]) => OptionalPromise<R>): Promises<R>;
+        spread(this: Promises<T & ArrayLike<any>>, fn: (...args: (T[keyof T & number])[]) => IOptionalPromise<T>): Promises<T>;
+        spread<R>(this: Promises<T & ArrayLike<any>>, fn: (...args: (T[keyof T & number])[]) => IOptionalPromise<R>): Promises<R>;
     }
 }
diff --git a/modules/timeout/index.ts b/modules/timeout/index.ts
index e311d1d..e271ac4 100644
--- a/modules/timeout/index.ts
+++ b/modules/timeout/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { IExecute } from '@promises/interfaces';
+import { IExecutor } from '@promises/interfaces';
 
 /**
  * @example
@@ -20,10 +20,10 @@ import { IExecute } from '@promises/interfaces';
  *  });
  * ```
  */
-function timeoutStatic<T>(execute: IExecute<T>, ms?: number): Promises<T> {
+function timeoutStatic<T>(executor: IExecutor<T>, ms?: number): Promises<T> {
     return new Promises((resolve, reject) => {
         setTimeout(() => {
-            execute(resolve, reject);
+            executor(resolve, reject);
         }, ms);
     });
 }
diff --git a/modules/times-parallel/index.ts b/modules/times-parallel/index.ts
index 417ede9..bc9ea80 100644
--- a/modules/times-parallel/index.ts
+++ b/modules/times-parallel/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -29,7 +29,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  // => [9, 6, 3]
  * ```
  */
-function timesParallelStatic<T extends any[]>(times: OptionalPromise<number>, fn: (time: number) => OptionalPromise<T[keyof T & number]>): Promises<T> {
+function timesParallelStatic<T extends any[]>(times: IOptionalPromise<number>, fn: (time: number) => IOptionalPromise<T[keyof T & number]>): Promises<T> {
     return Promises.resolve(times).then((times) => {
         return new Promises((resolve, reject) => {
             let length: number = times;
diff --git a/modules/times-series/index.ts b/modules/times-series/index.ts
index e8765b0..9b8cfac 100644
--- a/modules/times-series/index.ts
+++ b/modules/times-series/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -29,7 +29,7 @@ import { OptionalPromise } from '@promises/interfaces';
  *  // => [9, 6, 3]
  * ```
  */
-function timesSeriesStatic<T extends any[]>(times: OptionalPromise<number>, fn: (time: number) => OptionalPromise<T[keyof T & number]>): Promises<T> {
+function timesSeriesStatic<T extends any[]>(times: IOptionalPromise<number>, fn: (time: number) => IOptionalPromise<T[keyof T & number]>): Promises<T> {
     return Promises.resolve(times).then((times: number) => {
         let each = Promises.resolve();
         let length: number = times;
diff --git a/modules/wrap/index.ts b/modules/wrap/index.ts
index 4c028e3..b3ecc57 100644
--- a/modules/wrap/index.ts
+++ b/modules/wrap/index.ts
@@ -5,7 +5,7 @@
  */
 
 import Promises from '@promises/core';
-import { OptionalPromise } from '@promises/interfaces';
+import { IOptionalPromise } from '@promises/interfaces';
 
 /**
  * @example
@@ -24,16 +24,16 @@ import { OptionalPromise } from '@promises/interfaces';
  * ```
  */
 function wrapStatic<R>(fn: () => R, context?: any): () => Promises<R>;
-function wrapStatic<P1, R>(fn: (p1: P1) => R, context?: any): (p1: OptionalPromise<P1>) => Promises<R>;
-function wrapStatic<P1, P2, R>(fn: (p1: P1, p2: P2) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>) => Promises<R>;
-function wrapStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>) => Promises<R>;
-function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10) => R, context?: any): (p1: OptionalPromise<P1>, p2: OptionalPromise<P2>, p3: OptionalPromise<P3>, p4: OptionalPromise<P4>, p5: OptionalPromise<P5>, p6: OptionalPromise<P6>, p7: OptionalPromise<P7>, p8: OptionalPromise<P8>, p9: OptionalPromise<P9>, p10: OptionalPromise<P10>) => Promises<R>;
+function wrapStatic<P1, R>(fn: (p1: P1) => R, context?: any): (p1: IOptionalPromise<P1>) => Promises<R>;
+function wrapStatic<P1, P2, R>(fn: (p1: P1, p2: P2) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>) => Promises<R>;
+function wrapStatic<P1, P2, P3, R>(fn: (p1: P1, p2: P2, p3: P3) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, P6, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, P6, P7, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>) => Promises<R>;
+function wrapStatic<P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, R>(fn: (p1: P1, p2: P2, p3: P3, p4: P4, p5: P5, p6: P6, p7: P7, p8: P8, p9: P9, p10: P10) => R, context?: any): (p1: IOptionalPromise<P1>, p2: IOptionalPromise<P2>, p3: IOptionalPromise<P3>, p4: IOptionalPromise<P4>, p5: IOptionalPromise<P5>, p6: IOptionalPromise<P6>, p7: IOptionalPromise<P7>, p8: IOptionalPromise<P8>, p9: IOptionalPromise<P9>, p10: IOptionalPromise<P10>) => Promises<R>;
 function wrapStatic(fn, context?) {
     return function (...args) {
         return Promises.all(args).then((args) => {
diff --git a/test/for-each-parallel.spec.ts b/test/for-each-parallel.spec.ts
index a17a380..ce86d41 100644
--- a/test/for-each-parallel.spec.ts
+++ b/test/for-each-parallel.spec.ts
@@ -1,11 +1,11 @@
 import Promises from '@promises/core';
-import { Dictionary } from '@promises/interfaces';
+import { IDictionary } from '@promises/interfaces';
 import forEachParallel from '@promises/for-each-parallel';
 
 describe('forEachParallel', () => {
     it('should be parallel iterator on object with identity function and return the object', () => {
-        let object: Dictionary<number> = { a: 1, b: 2, c: 3 };
-        return forEachParallel(object).then((result: Dictionary<number>) => {
+        let object: IDictionary<number> = { a: 1, b: 2, c: 3 };
+        return forEachParallel(object).then((result: IDictionary<number>) => {
             expect(object).toBe(result);
         });
     });
diff --git a/test/for-each-right-series.spec.ts b/test/for-each-right-series.spec.ts
index f83f82c..8558be1 100644
--- a/test/for-each-right-series.spec.ts
+++ b/test/for-each-right-series.spec.ts
@@ -1,11 +1,11 @@
 import Promises from '@promises/core';
-import { Dictionary } from '@promises/interfaces';
+import { IDictionary } from '@promises/interfaces';
 import forEachRightSeries from '@promises/for-each-right-series';
 
 describe('forEachRightSeries', () => {
     it('should be series iterator on object with identity function and return the object', () => {
-        let object: Dictionary<number> = { a: 1, b: 2, c: 3 };
-        return forEachRightSeries(object).then((result: Dictionary<number>) => {
+        let object: IDictionary<number> = { a: 1, b: 2, c: 3 };
+        return forEachRightSeries(object).then((result: IDictionary<number>) => {
             expect(object).toBe(result);
         });
     });
diff --git a/test/for-each-series.spec.ts b/test/for-each-series.spec.ts
index 2bbce7c..ed04d31 100644
--- a/test/for-each-series.spec.ts
+++ b/test/for-each-series.spec.ts
@@ -1,5 +1,5 @@
 import Promises from '@promises/core';
-import { Dictionary } from '@promises/interfaces';
+import { IDictionary } from '@promises/interfaces';
 import forEachSeries from '@promises/for-each-series';
 
 describe('forEachSeries', () => {
@@ -11,14 +11,14 @@ describe('forEachSeries', () => {
     });
 
     it('should be series iterator on the object whit void iteratee and return the object without change', () => {
-        let object: Dictionary<number> = { a: 0, b: 1, c: 2 };
+        let object: IDictionary<number> = { a: 0, b: 1, c: 2 };
         let objectKeys = Object.keys(object);
         let count: number = 0;
         return forEachSeries(object, (value, key, object) => {
             expect(value).toBe(count);
             expect(key).toBe(objectKeys[count]);
             count++;
-        }).then((returnObject: Dictionary<number>) => {
+        }).then((returnObject: IDictionary<number>) => {
             expect(count).toBe(objectKeys.length);
             expect(returnObject).toBe(object);
         });