diff --git a/node-mysql-wrapper/node-mysql-wrapper.d.ts b/node-mysql-wrapper/node-mysql-wrapper.d.ts
new file mode 100644
index 000000000..4285c2f50
--- /dev/null
+++ b/node-mysql-wrapper/node-mysql-wrapper.d.ts
@@ -0,0 +1,134 @@
+// Type definitions for node-mysql-wrapper
+// Project: https://github.com/kataras/node-mysql-wrapper
+// Definitions by: Makis Maropoulos <https://github.com/kataras>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+///<reference path='./mysql.d.ts' />
+///<reference path='./bluebird.d.ts' />
+
+declare module "node-mysql-wrapper" {
+    import Mysql = require("mysql");
+
+    function MySQLWrapperBuilder(connection: string | Mysql.IConnection, ...useOnlyTables: string[]): MySQLWrapper;
+
+    enum EVENT_TYPES {
+        INSERT, UPDATE, DELETE, SAVE
+    }
+
+    interface MySQLConnection {
+        constructor(connection: string | Mysql.IConnection);
+
+        create(connectionUri: string);
+        create(connection: Mysql.IConnection);
+
+        attach(connection: Mysql.IConnection): void;
+        end(callback: () => void): void;
+        destroy(): void;
+        link<U>(callback?: () => void): Promise<U>;
+        connect<U>(callback?: () => void): Promise<U>;
+
+        useOnly(...useOnlyTables: string[]): void;
+
+        fetchDatabaseInfornation<U>(): Promise<U>;
+
+        escape(val: string): string;
+        notice(tableWhichCalled: string, queryStr: string, parsedResults: Object[]);
+        fireEvent(tableWhichCalled: string, queryStr: string, parsedResults: Object[]);
+
+        watch(tableName: string, evtType: EVENT_TYPES | string, callback: (parsedResults: Object[]) => void): void;
+        on(tableName: string, evtType: EVENT_TYPES | string, callback: (parsedResults: Object[]) => void): void;
+        unwatch(tableName: string, evtType: EVENT_TYPES | string, callbackToRemove: () => void): void;
+        off(tableName: string, evtType: EVENT_TYPES | string, callbackToRemove: () => void): void;
+
+        query(mysqlQuery: Mysql.IQueryFunction): void;
+
+        table(tableName: string): MySQLTable;
+    }
+
+    interface MySQLTable {
+        constructor(tableName: string, connection: MySQLConnection);
+
+        setColumns(columns: string[]);
+
+        setPrimaryKey(primaryKeyColumnName: string);
+
+        toString(): string;
+
+        model(jsObject: Object): MySQLModel;
+
+        watch(evtType: EVENT_TYPES | string, callback: (parsedResults: Object[]) => void);
+        on(evtType: EVENT_TYPES | string, callback: (parsedResults: Object[]) => void);
+        unwatch(evtType: EVENT_TYPES|string, callbackToRemove: () => void);
+        off(evtType: EVENT_TYPES|string, callbackToRemove: () => void);
+        
+        ///START DYNAMIC METHODS FOR TABLES CANNOT BE PRE-DEFINED WITH DYNAMIC WAY, YET, SO:
+        find<U>(jsObject: Object, callback?: (results: Object[]) => void): Promise<U>;
+        save<U>(jsObject: Object, callback?: (results: Object[]) => void): Promise<U>;
+        remove<U>(jsObject: Object, callback?: (results: Object[]) => void): Promise<U>;
+        delete<U>(jsObject: Object, callback?: (results: Object[]) => void): Promise<U>;
+        safeDelete<U>(jsObject: Object, callback?: (results: Object[]) => void): Promise<U>;
+        ///END 
+        findAll<U>(callback?: (results: Object[]) => void): Promise<U>;
+
+        extend(functionName: string, functionToBeSupported: () => any);
+
+        has(extendedFunctionName: string);
+
+    }
+
+    interface MySQLModel {
+        public EQUAL_TO_PROPERTY_SYMBOL: string;
+
+        constructor(table: MySQLTable, jsObject: Object);
+
+        toObjectProperty(columnKey: string): string;
+        toRowProperty(objectKey: string): string;
+
+        create(jsObject: Object): MySQLModel;
+        reUse(jsObject: Object): MySQLModel;
+
+        toRow(): void;
+        getRawObject(): Object;
+
+        parseTable(mysqlTableToSearch: String, parentObject: Object);
+        parseResult(result: Object, tablesToSearch: string[]);
+
+        find<U>(parentObj?: Object): Promise<U>;
+        findAll<U>(): Promise<U>;
+        save<U>(): Promise<U>;
+        safeDelete<U>(): Promise<U>;
+        remove<U>(): Promise<U>;
+        delete<U>(): Promise<U>;
+
+    }
+
+    interface MySQLWrapper {
+        constructor(connection?: MySQLConnection);
+
+        setConnection(connection: MySQLConnection): void;
+
+        useOnly(...useOnlyTables: string[]): void;
+
+        has(tableName: string): boolean;
+        has(tableName: string, methodName: string): boolean;
+
+        ready(callback: () => void): void;
+        noticeReady(): void;
+        removeReadyListener(callback: () => any): void;
+
+        query: Mysql.IQueryFunction;
+
+        destroy(): void;
+        end(callback?: () => void): void;
+
+        when<U>(): Promise<U[]>;
+
+        ///START: WE CANNOT PRE-DEFINE THE DYNAMIC TABLES INTO PROPERTIES, SO WE USE INDEX(STRING-TABLENAME) TO GET A TABLE
+        table(tableName: string): MySQLTable;
+        ///END
+    }
+
+    export = MySQLWrapperBuilder;
+
+
+}