Merge branch 'master' of https://github.com/borisyankov/DefinitelyTyped into ui-grid

# By Makis Maropoulos (6) and others
# Via Horiuchi_H (9) and herrmanno (1)
* 'master' of https://github.com/borisyankov/DefinitelyTyped:
  Added observe-js definition
  I moved the project, update the project's url here also
  Add the helpers property to the Handlebars module
  Updated node-jsfl-runner to 0.2.4
  Updating lovefield definitions for Lovefield v2.0.62.
  Update node-mysql-wrapper-tests.ts
  Update node-mysql-wrapper.d.ts
  Update node-mysql-wrapper-tests.ts
  Update node-mysql-wrapper-tests.ts
  Update to V2.3.6.
  Refactoring of interfaces for SlickGrid event args
  add archiver
  update version
  update version
  update serve-favicon
  update cookie-parser

archiver/archiver-test.ts

@@ -0,0 +1,14 @@
+/// <reference path="archiver.d.ts" />
+/// <reference path="../node/node.d.ts" />
+
+import Archiver = require('archiver');
+import FS = require('fs');
+
+var archiver = Archiver.create('zip');
+
+var writeStream = FS.createWriteStream('./archiver.d.ts');
+var readStream = FS.createReadStream('./archiver.d.ts');
+
+archiver.pipe(writeStream);
+archiver.append(readStream, {name: 'archiver.d.ts'});
+archiver.finalize();

archiver/archiver.d.ts

@@ -0,0 +1,41 @@
+// Type definitions for archiver v0.15.0
+// Project: https://github.com/archiverjs/node-archiver
+// Definitions by: Esri <https://github.com/archiverjs/node-archiver>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/* =================== USAGE ===================
+
+    import Archiver = require('archiver);
+    var archiver = Archiver.create('zip');
+    archiver.pipe(FS.createWriteStream('xxx'));
+    archiver.append(FS.createReadStream('xxx'));
+    archiver.finalize();
+
+ =============================================== */
+
+/// <reference path="../node/node.d.ts" />
+declare module "archiver" {
+    import * as FS from 'fs';
+    
+    interface nameInterface {
+        name?: string;
+    }
+        
+    interface Archiver {
+        pipe(writeStream: FS.WriteStream): void;
+        append(readStream: FS.ReadStream, name: nameInterface): void;
+        finalize(): void;
+    }
+    
+    interface Options {
+        
+    }
+    
+    function archiver(format: string, options?: Options): Archiver;
+    
+    namespace archiver {
+        function create(format: string, options?: Options): Archiver;
+    }
+    
+    export = archiver;
+}

cookie-parser/cookie-parser.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for cookie-parser
+// Type definitions for cookie-parser v1.3.4
 // Project: https://github.com/expressjs/cookie-parser
 // Definitions by: Santi Albo <https://github.com/santialbo/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -8,5 +8,6 @@
 declare module "cookie-parser" {
     import express = require('express');
     function e(secret?: string, options?: any): express.RequestHandler;
+    namespace e{}
     export = e;
 }

handlebars/handlebars-tests.ts

@@ -80,3 +80,5 @@ Handlebars.registerHelper('fullName', (person: typeof context.author) => {
 });
 
 var escapedExpression = Handlebars.Utils.escapeExpression('<script>alert(\'xss\');</script>');
+
+Handlebars.helpers !== undefined;

handlebars/handlebars.d.ts

@@ -18,6 +18,7 @@ declare module Handlebars {
     export var Utils: typeof hbs.Utils;
     export var logger: Logger;
     export var templates: HandlebarsTemplates;
+    export var helpers: any;
 
     export module AST {
         export var helpers: hbs.AST.helpers;

lovefield/lovefield-tests.ts

@@ -43,6 +43,8 @@ function main(): void {
       }).then(
       function() {
         return todoDb.select(lf.fn.count()).from(itemSchema).exec();
+      }).then(function() {
+        return todoDb.export();
       });
 }
 

lovefield/lovefield.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Lovefield v2.0.56
+// Type definitions for Lovefield v2.0.62
 // Project: http://google.github.io/lovefield/
 // Definitions by: freshp86 <https://github.com/freshp86>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -18,6 +18,16 @@ declare module lf {
     STRING
   }
 
+  export enum ConstraintAction {
+    RESTRICT,
+    CASCADE
+  }
+
+  export enum ConstraintTiming {
+    IMMEDIATE,
+    DEFERRABLE
+  }
+
   export interface Binder {
     getIndex(): number
   }
@@ -56,7 +66,9 @@ declare module lf {
     close(): void
     createTransaction(type?: TransactionType): Transaction
     delete(): query.Delete
+    export(): Promise<Object>
     getSchema(): schema.Database
+    import(data: Object): Promise<void>
     insertOrReplace(): query.Insert
     insert(): query.Insert
     observe(query: query.Select, callback: Function): void
@@ -174,9 +186,16 @@ declare module lf {
       order: Order
     }
 
+    type RawForeignKeySpec = {
+      local: string
+      ref: string
+      action: lf.ConstraintAction
+      timing: lf.ConstraintAction
+    }
+
     export interface TableBuilder {
       addColumn(name: string, type: lf.Type): TableBuilder
-      addForeignKey(): TableBuilder
+      addForeignKey(name: string, spec: RawForeignKeySpec): TableBuilder
       addIndex(
           name: string, columns: Array<string>|Array<IndexedColumn>,
           unique?: boolean, order?: Order): TableBuilder

node-jsfl-runner/node-jsfl-runner-tests.ts

@@ -8,11 +8,13 @@ let myJSFL: jsfl.JSFL = {
   }
 }
 
+let flashLocation: string = '';
+
 jsfl.createJSFL(myJSFL, 'fileName.jsfl', ['Hello!'], (err: NodeJS.ErrnoException) => {
 
 });
 
-jsfl.runJSFL('fileName.jsfl', (err: NodeJS.ErrnoException) => {
+jsfl.runJSFL(flashLocation, 'fileName.jsfl', (err: NodeJS.ErrnoException) => {
 
 });
 

node-jsfl-runner/node-jsfl-runner.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for node-jsfl-runner
+// Type definitions for node-jsfl-runner v0.2.4
 // Project: https://www.npmjs.com/package/node-jsfl-runner
 // Definitions by: Michael Randolph <https://github.com/mrand01>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -28,8 +28,9 @@ declare module "node-jsfl-runner" {
   
   /**
    * Runs a JSFL file
+   * @param flashLocation Path to Flash executable
    * @param fileName Path to JSFL file to run
    * @param callback Callback
    */
-  function runJSFL(fileName: string, callback: (err: NodeJS.ErrnoException) => void): void;
+  function runJSFL(flashLocation:string, fileName: string, callback: (err: NodeJS.ErrnoException) => void): void;
 }

node-mysql-wrapper/node-mysql-wrapper-tests.ts

@@ -1,4 +1,7 @@
 /// <reference path="./node-mysql-wrapper.d.ts" />
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../bluebird/bluebird.d.ts" />
+
 var express = require('express');
 var app = express();
 var server = require('http').createServer(app);
@@ -9,42 +12,37 @@ class User { //or interface
     userId: number;
     username: string;
     mail: string;
+    password:string;
     comments: Comment[];
+    myComments: Comment[];
+    info: UserInfo;
 }
 
 interface Comment {
     commentId: number;
     content: string;
+    likes: CommentLike[];
 
 }
+interface CommentLike {
+    commentLikeId: number;
+    userId: number;
+    commentId: number;
+}
+
+interface UserInfo {
+    userInfoId: number;
+    userId: number;
+    hometown: string;
+}
 
 db.ready(() => {
 
 
     var usersDb = db.table<User>("users");
-    usersDb.rules.orderBy("userId", true);
-  
+    
+    //or var usersDb = db.table("users"); if you don't want intel auto complete from your ide/editor
 
-     usersDb.findAll().then(users=> {
-             users.forEach(user=> {
-                 console.log(user.userId);
-             });
-     });
-    
-  
-    //define new table rules: usersDb.rules.clear().orderBy....limit....groupBy...
-    
-    //define rules but keep unchanged (table's rules) in find method:
-    usersDb.find({ yearsOld: 22 }, (_users) => {
-    
-        console.log("-------------------------------------------------------");
-        _users.forEach(_user=> {
-            console.log(_user.userId + " " + _user.username + " found with limit 3 but this doesnt...");
-
-        });
-
-    }).limit(3).execute();
-    
     usersDb.findById(16, (_user) => {
 
         console.log("TEST1: \n");
@@ -56,20 +54,27 @@ db.ready(() => {
      }, (err) => { console.log("ERROR ON FETCHING FINDBY ID: " + err) });
    */
 
-    usersDb.find({ userId: 18, comments: { userId: '=' } }, _users=> {
-
-        var _user = _users[0];
-
-        console.log("TEST2: \n");
-        console.log(_user.username + " with ");
-        console.log(_user.comments.length + " comments ");
-        _user.comments.forEach(_comment=> {
-            console.log("--------------\n" + _comment.content);
+    usersDb.findSingle(
+        {
+            userId: 18,
+            myComments: {
+                userId: '=',
+                tableRules: { //NEW: SET rules to joined tables too!
+                    table: "comments", //NEW SET table name inside any property u want!
+                    limit: 50,
+                    orderByDesc: "commentId" //give me the first 50 comments ordered by -commentId (DESC) from table 'comments' and put them at 'myComments' property inside the result object.
+                }
+            }
+        }).then(_user=> { // to get this promise use : .promise() 
+        console.log("\n-------------TEST 2 ------------\n");
+            console.log(_user.username + " with ");
+            console.log(_user.myComments.length + " comments ");
+            _user.myComments.forEach(_comment=> {
+                console.log("--------------\n" + _comment.content);
+            });
         });
 
-    }).execute();
-
-    usersDb.safeRemove(5620, answer=> {
+    usersDb.remove(5620, answer=> {
         console.log("TEST 3: \n");
         console.log(answer.affectedRows + ' (1) has removed from table:  ' + answer.table);
 
@@ -86,8 +91,107 @@ db.ready(() => {
     });
 
 
+
+    usersDb.find(
+        {
+            yearsOld: 22,
+            comments: {
+                userId: "=",
+                tableRules: {
+                    limit: 2
+                }
+            }
+
+        }, (_users) => {
+         
+            console.log("---------------TEST 6----------------------------------------");
+            _users.forEach(_user=> {
+                console.log(_user.userId + " " + _user.username + " found with " + _user.comments.length + " comments");
+
+            });
+
+        });
+    //if no rules setted to find method  it's uses the table's rules ( if exists)
+    
+    
+    
+    let _criteriaFromBuilder = usersDb.criteria
+        .except("password") // or .exclude(...columns). the only column you cannot except/exclude is the primary key (because it is used at where clause), be careful.
+        .where("userId", 24)
+        .joinAs("info", "userInfos", "userId") 
+        .at("info")
+        .limit(1) //because we make it limit 1 it will return this result as object not as array.
+        .parent()
+        .joinAs("myComments", "comments", "userId")  
+        .at("myComments").limit(2)
+        .joinAs("likes", "commentLikes", "commentId")
+        .original().orderBy("userId", true).build();
+        
+    /* console.dir(_criteriaFromBuilder);
+     prints this object: ( of course you can create your own in order to pass it on .find table methods )
+    {
+        userId:23,
+        
+        myComments:{
+            userId: '=',
+            
+            tableRules:{
+                table: 'comments',
+                limit:2
+               
+            },
+            
+            likes:{
+                commentId: '=',
+                
+                tableRules:{
+                    table: 'commentLikes'
+                }
+               
+            }
+        },
+        
+        tableRules:{ 
+            orderByDesc: 'userId',
+            except: ['password']
+        }
+        
+    }
+    
+    
+    */
+    
+
+
+    usersDb.find(_criteriaFromBuilder).then(_users=> {
+        console.log("\n----------------\nTEST ADVANCED 1\n-------------------\n ");
+        _users.forEach(_user=> {
+            console.log(_user.userId + " " + _user.username);
+
+            if (_user.info !== undefined) {
+                console.log(' from ' + _user.info.hometown);
+                //console.dir(_user.userInfos);
+            }
+
+            if (_user.myComments !== undefined) {
+                _user.myComments.forEach(_comment=> {
+                    console.log(_comment.commentId + " " + _comment.content);
+
+                    if (_comment.likes !== undefined) {
+                        console.log(' with ' + _comment.likes.length + ' likes!');
+                    }
+                });
+            }
+        });
+
+    });
+
+
 });
 
+server.on('uncaughtException', function(err:any) {
+    console.log(err);
+})
 
 var httpPort = 1193;//config.get('Server.port') || 1193;
 server.listen(httpPort, function() {

node-mysql-wrapper/node-mysql-wrapper.d.ts

@@ -1,5 +1,5 @@
 // Type definitions for node-mysql-wrapper
-// Project: https://github.com/kataras/node-mysql-wrapper
+// Project: https://github.com/nodets/node-mysql-wrapper
 // Definitions by: Makis Maropoulos <https://github.com/kataras>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
@@ -12,11 +12,42 @@ declare module "node-mysql-wrapper" {
     import {EventEmitter} from 'events';
 
     var EQUAL_TO_PROPERTY_SYMBOL: string;
+    var TABLE_RULES_PROPERTY: string;
+
+    type DeleteAnswer = {
+        affectedRows: number;
+        table: string;
+    };
+
+    type RawRules = {
+        table: string,
+        begin: string,
+        orderBy: string,
+        orderByDesc: string,
+        groupBy: string,
+        limit: number, // limit = limitStart  =0 and limitEnd = limit.
+        limitStart: number,
+        limitEnd: number,
+        end: string
+
+    };
+
+    type TableToSearchPart = { tableName: string, propertyName: string };
 
     interface Map<T> {
         [index: string]: T;
     }
 
+    interface IQuery<T> {
+        _table: Table<T>;
+        execute(rawCriteria: any, callback?: (_results: any) => any): Promise<any>;
+    }
+
+    interface IQueryConstructor<T> {
+        new (_table: Table<T>): IQuery<T>;
+    }
+
+
     class Helper {
         /** 
          * Callback like forEach
@@ -61,9 +92,7 @@ declare module "node-mysql-wrapper" {
          * @return {string}
          */
         static toRowProperty(objectKey: string): string;
-        
     
-        
         /**
          * Iterate object's keys and return their values to the callback.
          * @param {Map<T>} map the object.
@@ -80,17 +109,38 @@ declare module "node-mysql-wrapper" {
         * @returnType {U}
         * @return {U}
         */
+
         static forEachKey<T, U>(map: Map<T>, callback: (key: string) => U): U;
+        
+        /**
+         * Checks if anything is a function.
+         * @param {functionToCheck} the object or function to pass
+         * @return boolean
+         */
+        static isFunction(functionToCheck: any): boolean;
+        
+        /**
+         * Checks if an object has 'tableRules' property.
+         * @param {obj} the object to pass
+         * @return boolean
+         */
+        static hasRules(obj: any): boolean;
     }
 
-    interface ICriteria {
+
+    interface ICriteriaParts {
         rawCriteriaObject: any;
-        tables: string[];
+        tables: TableToSearchPart[];
         noDatabaseProperties: string[];
         whereClause: string;
+
+        selectFromClause<T>(_table: Table<T>): string;
+
     }
 
-    class Criteria implements ICriteria {
+
+
+    class CriteriaParts implements ICriteriaParts {
         
         /**
          * The raw format of the criteria eg: {yearsOld:22}.
@@ -100,7 +150,7 @@ declare module "node-mysql-wrapper" {
         /**
          * Which tables to search after the find method of the proto table finish.
          */
-        tables: string[];
+        tables: TableToSearchPart[];
         
         /**
          * The properties of the criteria which don't belong to the database's table.
@@ -112,10 +162,12 @@ declare module "node-mysql-wrapper" {
          */
         whereClause: string;
 
-        constructor(rawCriteriaObject: any, tables: string[], noDatabaseProperties: string[], whereClause: string);
+        constructor(rawCriteriaObject: any, tables: TableToSearchPart[], noDatabaseProperties: string[], whereClause: string);
+
+        selectFromClause<T>(_table: Table<T>): string;
     }
 
-    class CriteriaBuilder<T> {
+    class CriteriaDivider<T> {
         private _table;
         constructor(table: Table<T>);
         
@@ -125,70 +177,131 @@ declare module "node-mysql-wrapper" {
          * @returnType {Criteria}
          * @return {Criteria}
          */
-        build(rawCriteriaObject: any): Criteria;
+        build(rawCriteriaObject: any): CriteriaParts;
     }
 
     class SelectQueryRules {
-        orderByClause: string;
-        groupByClause: string;
-        limitClause: string;
-
-
+        private lastPropertyClauseName: string;
+        manuallyEndClause: string;
+        manuallyBeginClause: string;
+        exceptColumns: string[];
+        orderByColumn: string;
+        orderByDescColumn: string;
+        groupByColumn: string;
+        limitStart: number;
+        limitEnd: number;
+        public tableName: string; //auto den benei oute sto last, oute sto from.
         static build(): SelectQueryRules;
-        static build(parentRule?: SelectQueryRules): SelectQueryRules;
+        private last(propertyClauseName);
+        except(...columns: string[]): SelectQueryRules;
+        
+        /**
+         * Same as .except(...columns)
+         */
+        exclude(...columns: string[]): SelectQueryRules;
 
         orderBy(columnKey: string, descending?: boolean): SelectQueryRules;
-
         groupBy(columnKey: string): SelectQueryRules;
-
         limit(limitRowsOrStart: number, limitEnd?: number): SelectQueryRules;
-
+        appendToBegin(manualAfterWhereString: string): SelectQueryRules;
+        appendToEnd(manualAfterWhereString: string): SelectQueryRules;
+        append(appendToCurrent: string): SelectQueryRules;
         clearOrderBy(): SelectQueryRules;
-
         clearGroupBy(): SelectQueryRules;
-
         clearLimit(): SelectQueryRules;
-
+        clearEndClause(): SelectQueryRules;
+        clearBeginClause(): SelectQueryRules;
         clear(): SelectQueryRules;
-
         from(parentRule: SelectQueryRules): SelectQueryRules;
-
+        isEmpty(): boolean;
         toString(): string;
+        toRawObject(): RawRules;
+        static toString(rules: SelectQueryRules): string;
+        static toRawObject(rules: SelectQueryRules): RawRules;
+        static fromRawObject(obj: RawRules): SelectQueryRules;
     }
 
-    class SelectQuery<T> {
+    class CriteriaBuilder<T>{
 
-        private _rules: SelectQueryRules;
-        private _table: Table<T>;
-        private _criteriaRawJsObject: any;
-        private _callback: (_results: T[]) => any;
-        private callback: (resolve?: (thenableOrResult?: T | Promise.Thenable<T>) => void, reject?: (error?: any) => void) => void;
+        private rawCriteria: any;
+        private primaryTable: Table<T>;
+        private parentBuilder: CriteriaBuilder<any>;
 
-        constructor(table: Table<T>, criteriaRawJsObject: any, callback?: (_results: T[]) => any);
+        constructor(primaryTable: Table<T>); //to arxiko apo to Table.ts 9a benei
+        constructor(primaryTable: Table<T>, tableName: string, parentBuilder: CriteriaBuilder<any>);// auta 9a benoun apo to parent select query.
+        constructor(primaryTable: Table<T>, tablePropertyName?: string, parentBuilder?: CriteriaBuilder<any>);
 
-        orderBy(columnKey: string, descending?: boolean): SelectQuery<T>;
+        except(...columns: string[]): CriteriaBuilder<T>;
+        
+        /**
+	    * Same as .except(...columns)
+	    */
+        exclude(...columns: string[]): CriteriaBuilder<T>;
 
-        groupBy(columnKey: string): SelectQuery<T>;
+        where(key: string, value: any): CriteriaBuilder<T>;
 
-        limit(limitRowsOrStart: number, limitEnd?: number): SelectQuery<T>;
+        private createRulesIfNotExists(): void;
+
+        orderBy(column: string, desceding?: boolean): CriteriaBuilder<T>;
+
+        limit(start: number, end?: number): CriteriaBuilder<T>;
+
+        join(realTableName: string, foreignColumnName: string): CriteriaBuilder<T>;
+
+        joinAs(tableNameProperty: string, realTableName: string, foreignColumnName: string): CriteriaBuilder<T>;
+
+        at(tableNameProperty: string): CriteriaBuilder<T>;
+
+        parent(): CriteriaBuilder<T>;
+
+        original(): CriteriaBuilder<T>;
+        
+        /**
+         * Auto kanei kuklous mexri na paei sto primary table kai ekei na epistrepsei to sunoliko raw criteria gia execute i kati allo.
+         */
+        build(): any;
+
+        static from<T>(table: Table<T>): CriteriaBuilder<T>
+
+    }
+
+    class SelectQuery<T> implements IQuery<T> { // T for Table's result type.
+       
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        private parseQueryResult(result: any, criteria: ICriteriaParts): Promise<any>;
 
         /**
-        * Executes the select and returns the Promise.
-        */
-        promise(): Promise<T[]>;
-        
+         * Executes the select and returns the Promise.
+         */
+        promise(rawCriteria: any, callback?: (_results: T[]) => any): Promise<T[]>;
+
         /**
          * Exactly the same thing as promise().
          * Executes the select and returns the Promise.
-         */
-        execute(): Promise<T[]>;
-
-        then(onFulfill: (value: any[]) => any|Promise.Thenable<any>): Promise<any>;
-        then<U>(onFulfill: (value: T[]) => U|Promise.Thenable<U>, onReject: (error: any) => Promise.Thenable<U>, onProgress?: (note: any) => any): Promise<U>;
-        then<U>(onFulfill: (value: T[]) => U|Promise.Thenable<U>, onReject?: (error: any) => U, onProgress?: (note: any) => any): Promise<U>;
-
+        */
+        execute(rawCriteria: any, callback?: (_results: T[]) => any): Promise<T[]>;
     }
 
+    class SaveQuery<T> implements IQuery<T> {
+
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        execute(criteriaRawJsObject: any, callback?: (_result: T | any) => any): Promise<T | any>;
+    }
+
+    class DeleteQuery<T> implements IQuery<T>{
+
+        _table: Table<T>
+        constructor(_table: Table<T>);
+
+        execute(criteriaOrID: any | number | string, callback?: (_result: DeleteAnswer) => any): Promise<DeleteAnswer>;
+    }
+
+
+
     class Connection extends EventEmitter {
         
         /**
@@ -325,14 +438,17 @@ declare module "node-mysql-wrapper" {
     }
 
     class Table<T> {
-        private _name;
-        private _connection;
-        private _columns;
-        private _primaryKey;
-        private _criteriaBuilder;
-        private _rules;
+        private _name: string;
+        private _connection: Connection;
+        private _columns: string[];
+        private _primaryKey: string;
+        private _criteriaDivider: CriteriaDivider<T>;
+        private _rules: SelectQueryRules;
+        private _selectQuery: SelectQuery<T>
+        private _saveQuery: SaveQuery<T>;
+        private _deleteQuery: DeleteQuery<T>;
         constructor(tableName: string, connection: Connection);
-        
+
         /**
          * An array of all columns' names inside this table.
          */
@@ -355,9 +471,23 @@ declare module "node-mysql-wrapper" {
         
         /**
          * Set of the query rules that will be applied after the 'where clause' on each select query executed by this table. 
+         * @return {SelectQueryRules}
          */
         rules: SelectQueryRules;
         
+        /**
+         * Returns this table's criteria divider class.
+         * @return {CriteriaDivider}
+         */
+        criteriaDivider: CriteriaDivider<T>;
+        
+        /**
+         * Returns new Criteria Builder each time.
+         * Helps you  to make criteria raw js objects ready to use in find,remove and save methods.
+         * @return {CriteriaBuilder}
+         */
+        criteria: CriteriaBuilder<T>;
+        
         /**
         * Adds or turn on an event listener/watcher on a table for a 'database event'.
         * @param {string} evtType the event type you want to watch, one of these: ["INSERT", "UPDATE", "REMOVE", "SAVE"].
@@ -424,48 +554,31 @@ declare module "node-mysql-wrapper" {
          * @return {number | string}
          */
         getPrimaryKeyValue(jsObject: any): number | string;
-
-        parseQueryResult(result: any, criteria: ICriteria): Promise<any>;
         
         /**
          * 
          */
-        find(criteriaRawJsObject: any): SelectQuery<T>; // only criteria 
-        find(criteriaRawJsObject: any, callback: ((_results: T[]) => any)): SelectQuery<T>; // criteria and callback
-        find(criteriaRawJsObject: any, callback?: (_results: T[]) => any): SelectQuery<T>;
+        find(criteriaRawJsObject: any): Promise<T[]>; // only criteria 
+        find(criteriaRawJsObject: any, callback: ((_results: T[]) => any)): Promise<T[]>; // criteria and callback
+        find(criteriaRawJsObject: any, callback?: (_results: T[]) => any): Promise<T[]>;
+
+        findSingle(criteriaRawJsObject: any, callback?: (_result: T) => any): Promise<T>;
 
         findById(id: number|string): Promise<T>; // without callback
         findById(id: number | string, callback?: (result: T) => any): Promise<T>;
 
-        findAll(): SelectQuery<T>; // without callback
-        findAll(callback?: (_results: T[]) => any): SelectQuery<T>;
+        findAll(): Promise<T[]>; // only criteria and promise
+        findAll(tableRules: RawRules): Promise<T[]> // only rules and promise
+        findAll(tableRules?: RawRules, callback?: (_results: T[]) => any): Promise<T[]>;
+
 
         save(criteriaRawJsObject: any): Promise<any>; //without callback
         save(criteriaRawJsObject: any, callback?: (_result: any) => any): Promise<any>;
 
-        safeRemove(id: number | string): Promise<{
-            affectedRows: number;
-            table: string;
-        }>; //withoutcallback
-        safeRemove(id: number | string, callback?: (_result: {
-            affectedRows: number;
-            table: string;
-        }) => any): Promise<{
-            affectedRows: number;
-            table: string;
-        }>;
+        remove(id: number | string): Promise<DeleteAnswer>; // ID without callback
+        remove(criteriaRawObject: any): Promise<DeleteAnswer>; // criteria obj without callback
+        remove(criteriaOrID: any | number | string, callback?: (_result: DeleteAnswer) => any): Promise<DeleteAnswer>;
 
-        remove(criteriaRawObject: any): Promise<{
-            affectedRows: number;
-            table: string;
-        }>; // without callback
-        remove(criteriaRawJsObject: any, callback?: (_result: {
-            affectedRows: number;
-            table: string;
-        }) => any): Promise<{
-            affectedRows: number;
-            table: string;
-        }>;
     }
 
     class Wrapper {

observe-js/observe-js-test.ts

@@ -0,0 +1,111 @@
+/// <reference path="observe-js.d.ts" />
+
+module observejs {
+	
+	function Test_PathObserver() {
+		var obj = { foo: { bar: 'baz' } };
+		var defaultValue = 42;
+		var observer = new PathObserver(obj, 'foo.bar', defaultValue);
+		observer.open(function(newValue, oldValue) {
+		// respond to obj.foo.bar having changed value.
+		});
+	}
+	
+	
+	function Test_ArrayObserver() {
+		var arr = [0, 1, 2, 4];
+		var observer = new ArrayObserver(arr);
+		observer.open(function(splices) {
+		// respond to changes to the elements of arr.
+		splices.forEach(function(splice) {
+			splice.index; // the index position that the change occurred.
+			splice.removed; // an array of values representing the sequence of removed elements
+			splice.addedCount; // the number of elements which were inserted.
+		});
+		});
+	}
+	
+	function Test_ObejctObserver() {
+		var myObj = { id: 1, foo: 'bar' };
+		var observer = new ObjectObserver(myObj);
+		observer.open(function(added, removed, changed, getOldValueFn) {
+		// respond to changes to the obj.
+		Object.keys(added).forEach(function(property) {
+			property; // a property which has been been added to obj
+			added[property]; // its value
+		});
+		Object.keys(removed).forEach(function(property) {
+			property; // a property which has been been removed from obj
+			getOldValueFn(property); // its old value
+		});
+		Object.keys(changed).forEach(function(property) {
+			property; // a property on obj which has changed value.
+			changed[property]; // its value
+			getOldValueFn(property); // its old value
+		});
+		});
+	}
+	
+	function Test_CompounObserver() {
+		var obj = {
+			a: 1,
+			b: 2,
+		};
+		
+		var otherObj = { c: 3 };
+		
+		var observer = new CompoundObserver();
+		observer.addPath(obj, 'a');
+		observer.addObserver(new PathObserver(obj, 'b'));
+		observer.addPath(otherObj, 'c');
+		var logTemplate = 'The %sth value before & after:';
+		observer.open(function(newValues, oldValues) {
+		// Use for-in to iterate which values have changed.
+		for (var i in oldValues) {
+			console.log(logTemplate, i, oldValues[i], newValues[i]);
+		}
+		});
+	}
+	
+	function Test_ObserverTransform_1() {
+		var obj = { value: 10 };
+		var observer = new PathObserver(obj, 'value');
+		function getValue(value:any) { return value * 2 };
+		function setValue(value:any) { return value / 2 };
+		
+		var transform = new ObserverTransform(observer, getValue, setValue);
+		
+		// returns 20.
+		transform.open(function(newValue, oldValue) {
+		console.log('new: ' + newValue + ', old: ' + oldValue);
+		});
+		
+		obj.value = 20;
+		transform.deliver(); // 'new: 40, old: 20'
+		transform.setValue(4); // obj.value === 2;
+	}
+	
+	function Test_ObserverTransform_2() {
+		var obj = { a: 1, b: 2, c: 3 };
+		var observer = new CompoundObserver();
+		observer.addPath(obj, 'a');
+		observer.addPath(obj, 'b');
+		observer.addPath(obj, 'c');
+		var transform = new ObserverTransform(observer, function(values) {
+		var value = 0;
+		for (var i = 0; i < values.length; i++)
+			value += values[i]
+		return value;
+		});
+		
+		// returns 6.
+		transform.open(function(newValue, oldValue) {
+		console.log('new: ' + newValue + ', old: ' + oldValue);
+		});
+		
+		obj.a = 2;
+		obj.c = 10;
+		transform.deliver(); // 'new: 14, old: 6'
+	}
+
+}

observe-js/observe-js.d.ts

@@ -0,0 +1,250 @@
+// Type definitions for observe-js v0.5.5
+// Project: https://github.com/Polymer/observe-js
+// Definitions by: Oliver Herrmann <https://github.com/herrmanno/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module observejs {
+	
+	/*----------------------
+		Observable
+	----------------------*/
+		
+	interface Observable {
+		/**
+		 * Begins observation.
+		 * @param onChange the function that gets invoked if a change is detected
+		 * @param the target of observation
+		 */
+		open(onChange:(newValue:any, oldValue:any)=>any, receiver?:any):void
+
+		/**
+		 * Report any changes now (does nothing if there are no changes to report).
+		 */
+		deliver(): void
+		
+		/**
+		 * If there are changes to report, ignore them. Returns the current value of the observation.
+		 */
+		discardChanges():void
+		
+		/**
+		 * Ends observation. Frees resources and drops references to observed objects.
+		 */
+		close():void
+	}
+	
+	
+	/*----------------------
+		PathObserver
+	----------------------*/
+	
+	interface PathObserver_static {
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 * @param path specifies the paht to observe. If path === '' the receiver itself gets observed.
+		 * @param defaultValue the defaultValue
+		 */
+		new(receiver:any, path:string, defaultValue?:any): PathObserver_instance
+	}
+	
+	interface PathObserver_instance extends Observable {
+		/**
+		 * sets the observed value without notifying about the change.
+		 * @param value the value to set
+		 */
+		setValue(value:any): void
+	}
+	
+	/**
+	 * Observes a "value-at-a-path" from a given object: 
+	 */
+	var PathObserver: PathObserver_static
+	
+	
+	/*----------------------
+		ArrayObserver
+	----------------------*/
+	
+	interface splice {
+		
+		/**
+		 * the index position that the change occured
+		 */
+		index:number
+		
+		/**
+		 * an array of values representing the sequence of removed elements
+		 */
+		removed: Array<any>
+		
+		/**
+		 * the number of element which were inserted 
+		 */
+		addedCount:number
+	}
+	
+	interface ArrayObserver_static {
+		
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 */
+		new(receiver:Array<any>): ArrayObserver_instance
+		
+		/**
+		 * transforms a copy of an old state of an array into a copy of its current state.
+		 * @param previous array of old state
+		 * @param current array of current state
+		 * @param splices  splices to apply
+		 */
+		applySplices(previous:Array<any>, current:Array<any>, splices:Array<splice>):void
+	}
+	
+	interface ArrayObserver_instance extends Observable {
+		open(onChange:(splices:Array<splice>)=>any):void
+	}
+	
+	/**
+	 * ArrayObserver observes the index-positions of an Array and reports changes as the minimal set of "splices" which would have had the same effect.
+	 */
+	var ArrayObserver: ArrayObserver_static
+	
+	
+	/*----------------------
+		ObjectObserver
+	----------------------*/
+	
+	interface Properties {
+		[key:string]:any
+	}
+	
+	interface ObjectObserver_static {
+		
+		/**
+		 * Constructor
+		 * @param receiver the target for observation
+		 */
+		new(receiver:any): ObjectObserver_instance
+	}
+	
+	interface ObjectObserver_instance extends Observable {
+		open(onChange:(added:Properties, removed:Properties, changed:Properties, getOldValueFn:(property:string)=>any)=>any):void
+	}
+	
+	/**
+	 * Observes the set of own-properties of an object and their values
+	 */
+	var ObjectObserver: ObjectObserver_static
+	
+	
+	/*----------------------
+		CompounObserver
+	----------------------*/
+	
+	interface CompoundObserver_static {
+		
+		/**
+		 * Constructor
+		 */
+		new(): CompoundObserver_instance
+	}
+	
+	interface CompoundObserver_instance extends Observable {
+		open(onChange:(newValues:Array<any>, oldValue:Array<any>)=>any):void
+		
+		/**
+		 * Adds the receivers property at the specified path to the list of observables.
+		 * @param receiver the target for observation
+		 * @param path specifies the paht to observe. If path === '' the receiver itself gets observed.
+		 */
+		addPath(receiver:any, path:string):void
+		
+		/**
+		 * Adds an Observer to the list of observables.
+		 */
+		addObserver(observer:Observable):void
+	
+	}
+	
+	/**
+	 * CompoundObserver allows simultaneous observation of multiple paths and/or Observables.
+	 */
+	var CompoundObserver: CompoundObserver_static
+	
+	
+	
+	/*----------------------
+		ObserverTransform
+	----------------------*/
+	
+	interface ObserverTransform_static {
+		
+		/**
+		 * Constructor
+		 * @param observer the observer to transform
+		 * @param getValue function that proxys getting a value
+		 * @param setValue function that proxys setting a value
+		 */
+		new(observer:Observable, getValue:(value:any)=>any, setValue:(value:any)=>any): ObserverTransform_instance
+		
+		/**
+		 * Constructor
+		 * @param observer the observer to transform
+		 * @param valueFn function that gets invoked with all observed values. May return a single new value.
+		 */
+		new(observer:Observable, valueFn:(values:Array<any>)=>any): ObserverTransform_instance
+	}
+	
+	interface ObserverTransform_instance extends Observable {
+		/**
+		 * sets the observed value without notifying about the change.
+		 * @param value the value to set
+		 */
+		setValue(value:any): void
+	}
+	
+	/**
+	 * CompoundObserver allows simultaneous observation of multiple paths and/or Observables.
+	 */
+	var ObserverTransform: ObserverTransform_static
+	
+	
+	/*----------------------
+		Path
+	----------------------*/
+	
+	interface Path {
+		
+		/**
+		 * Returns the current value of the path from the provided object. If eval() is available,
+  		 * a compiled getter will be used for better performance. Like PathObserver above, undefined
+  		 * is returned unless you provide an overriding defaultValue.
+		 */
+		getValueFrom(object:any, defaultValue:any): any
+		
+		/**
+		 * Attempts to set the value of the path from the provided object. Returns true IFF the path
+  		 * was reachable and set.
+		 */
+		getValueFrom(object:any, newValue:any): any
+	}
+}
+
+declare module "observejs" {
+	var PathObserver: typeof observejs.PathObserver;
+	var ArrayObserver: typeof observejs.ArrayObserver;
+	var ObjectObserver: typeof observejs.ObjectObserver;
+	var CompoundObserver: typeof observejs.CompoundObserver;
+	var ObserverTransform: typeof observejs.ObserverTransform;
+	var Path: observejs.Path;
+	
+	export {
+		PathObserver,
+		ArrayObserver,
+		ObjectObserver,
+		CompoundObserver,
+		ObserverTransform,
+		Path
+	};
+}

serve-favicon/serve-favicon.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for serve-favicon 2.1.6
+// Type definitions for serve-favicon 2.2.0
 // Project: https://github.com/expressjs/serve-favicon
 // Definitions by: Uros Smolnik <https://github.com/urossmolnik/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -24,6 +24,8 @@ declare module "serve-favicon" {
         */
         maxAge?: number;
     }): express.RequestHandler;
+    
+    namespace serveFavicon{}
 
     export = serveFavicon;
 }

slickgrid/SlickGrid.d.ts

@@ -507,11 +507,11 @@ declare module Slick {
 		getEditor<T>(column: Column<T>): Editors.Editor<T>;
 	}
 
-	export interface FormatterFactory<T extends Slick.SlickData> {
+	export interface FormatterFactory<T extends SlickData> {
 		getFormatter(column: Column<T>): Formatter<any>;
 	}
 
-	export interface GridOptions<T extends Slick.SlickData> {
+	export interface GridOptions<T extends SlickData> {
 
 		/**
 		* Makes cell editors load asynchronously after a small delay. This greatly increases keyboard navigation speed.
@@ -863,7 +863,7 @@ declare module Slick {
 		* todo: no docs or comments available
 		* @return
 		**/
-		public getSortColumns(): Column<T>[];
+		public getSortColumns(): { columnId: string; sortAsc: boolean }[];
 
 		/**
 		* Updates an existing column definition and a corresponding header DOM element with the new title and tooltip.
@@ -1106,39 +1106,39 @@ declare module Slick {
 
 		// #region Events
 
-		public onScroll: Slick.Event<OnScrollEventData>;
-		public onSort: Slick.Event<OnSortEventData<T>>;
-		public onHeaderMouseEnter: Slick.Event<OnHeaderMouseEventData<T>>;
-		public onHeaderMouseLeave: Slick.Event<OnHeaderMouseEventData<T>>;
-		public onHeaderContextMenu: Slick.Event<OnHeaderContextMenuEventData<T>>;
-		public onHeaderClick: Slick.Event<OnHeaderClickEventData<T>>;
-		public onHeaderCellRendered: Slick.Event<OnHeaderCellRenderedEventData<T>>;
-		public onBeforeHeaderCellDestroy: Slick.Event<OnBeforeHeaderCellDestroyEventData<T>>;
-		public onHeaderRowCellRendered: Slick.Event<OnHeaderRowCellRenderedEventData<T>>;
-		public onBeforeHeaderRowCellDestroy: Slick.Event<OnBeforeHeaderRowCellDestroyEventData<T>>;
-		public onMouseEnter: Slick.Event<OnMouseEnterEventData>;
-		public onMouseLeave: Slick.Event<OnMouseLeaveEventData>;
-		public onClick: Slick.Event<OnClickEventData>;
-		public onDblClick: Slick.Event<OnDblClickEventData>;
-		public onContextMenu: Slick.Event<OnContextMenuEventData>;
-		public onKeyDown: Slick.Event<OnKeyDownEventData>;
-		public onAddNewRow: Slick.Event<OnAddNewRowEventData<T>>;
-		public onValidationError: Slick.Event<OnValidationErrorEventData<T>>;
-		public onColumnsReordered: Slick.Event<OnColumnsReorderedEventData>;
-		public onColumnsResized: Slick.Event<OnColumnsResizedEventData>;
-		public onCellChange: Slick.Event<OnCellChangeEventData<T>>;
-		public onBeforeEditCell: Slick.Event<OnBeforeEditCellEventData<T>>;
-		public onBeforeCellEditorDestroy: Slick.Event<OnBeforeCellEditorDestroyEventData<T>>;
-		public onBeforeDestroy: Slick.Event<OnBeforeDestroyEventData>;
-		public onActiveCellChanged: Slick.Event<OnActiveCellChangedEventData>;
-		public onActiveCellPositionChanged: Slick.Event<OnActiveCellPositionChangedEventData>;
-		public onDragInit: Slick.Event<OnDragInitEventData>;
-		public onDragStart: Slick.Event<OnDragStartEventData>;
-		public onDrag: Slick.Event<OnDragEventData>;
-		public onDragEnd: Slick.Event<OnDragEndEventData>;
-		public onSelectedRowsChanged: Slick.Event<OnSelectedRowsChangedEventData>;
-		public onCellCssStylesChanged: Slick.Event<OnCellCssStylesChangedEventData>;
-		public onViewportChanged: Slick.Event<OnViewportChangedEventData>;
+		public onScroll: Slick.Event<OnScrollEventArgs<T>>;
+		public onSort: Slick.Event<OnSortEventArgs<T>>;
+		public onHeaderMouseEnter: Slick.Event<OnHeaderMouseEventArgs<T>>;
+		public onHeaderMouseLeave: Slick.Event<OnHeaderMouseEventArgs<T>>;
+		public onHeaderContextMenu: Slick.Event<OnHeaderContextMenuEventArgs<T>>;
+		public onHeaderClick: Slick.Event<OnHeaderClickEventArgs<T>>;
+		public onHeaderCellRendered: Slick.Event<OnHeaderCellRenderedEventArgs<T>>;
+		public onBeforeHeaderCellDestroy: Slick.Event<OnBeforeHeaderCellDestroyEventArgs<T>>;
+		public onHeaderRowCellRendered: Slick.Event<OnHeaderRowCellRenderedEventArgs<T>>;
+		public onBeforeHeaderRowCellDestroy: Slick.Event<OnBeforeHeaderRowCellDestroyEventArgs<T>>;
+		public onMouseEnter: Slick.Event<OnMouseEnterEventArgs<T>>;
+		public onMouseLeave: Slick.Event<OnMouseLeaveEventArgs<T>>;
+		public onClick: Slick.Event<OnClickEventArgs<T>>;
+		public onDblClick: Slick.Event<OnDblClickEventArgs<T>>;
+		public onContextMenu: Slick.Event<OnContextMenuEventArgs<T>>;
+		public onKeyDown: Slick.Event<OnKeyDownEventArgs<T>>;
+		public onAddNewRow: Slick.Event<OnAddNewRowEventArgs<T>>;
+		public onValidationError: Slick.Event<OnValidationErrorEventArgs<T>>;
+		public onColumnsReordered: Slick.Event<OnColumnsReorderedEventArgs<T>>;
+		public onColumnsResized: Slick.Event<OnColumnsResizedEventArgs<T>>;
+		public onCellChange: Slick.Event<OnCellChangeEventArgs<T>>;
+		public onBeforeEditCell: Slick.Event<OnBeforeEditCellEventArgs<T>>;
+		public onBeforeCellEditorDestroy: Slick.Event<OnBeforeCellEditorDestroyEventArgs<T>>;
+		public onBeforeDestroy: Slick.Event<OnBeforeDestroyEventArgs<T>>;
+		public onActiveCellChanged: Slick.Event<OnActiveCellChangedEventArgs<T>>;
+		public onActiveCellPositionChanged: Slick.Event<OnActiveCellPositionChangedEventArgs<T>>;
+		public onDragInit: Slick.Event<OnDragInitEventArgs<T>>;
+		public onDragStart: Slick.Event<OnDragStartEventArgs<T>>;
+		public onDrag: Slick.Event<OnDragEventArgs<T>>;
+		public onDragEnd: Slick.Event<OnDragEndEventArgs<T>>;
+		public onSelectedRowsChanged: Slick.Event<OnSelectedRowsChangedEventArgs<T>>;
+		public onCellCssStylesChanged: Slick.Event<OnCellCssStylesChangedEventArgs<T>>;
+		public onViewportChanged: Slick.Event<OnViewportChangedEventArgs<T>>;
 		// #endregion Events
 
 		// #region Plugins
@@ -1177,74 +1177,78 @@ declare module Slick {
 		// #endregion Editors
 	}
 
-	export interface OnCellCssStylesChangedEventData {
+	export interface GridEventArgs<T extends SlickData> {
+		grid: Grid<T>;
+	}
+
+	export interface OnCellCssStylesChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		key: string;
 		hash: CellCssStylesHash;
 	}
 
-	export interface OnSelectedRowsChangedEventData {
+	export interface OnSelectedRowsChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		rows: number[];
 	}
 
-	export interface OnDragEndEventData {
+	export interface OnDragEndEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragEventData {
+	export interface OnDragEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragStartEventData {
+	export interface OnDragStartEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnDragInitEventData {
+	export interface OnDragInitEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		// todo: need to understand $canvas drag event parameter's 'dd' object
 		// the documentation is not enlightening
 	}
 
-	export interface OnActiveCellPositionChangedEventData {
+	export interface OnActiveCellPositionChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnActiveCellChangedEventData {
+	export interface OnActiveCellChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnBeforeDestroyEventData {
+	export interface OnBeforeDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnBeforeCellEditorDestroyEventData<T extends Slick.SlickData> {
+	export interface OnBeforeCellEditorDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		editor: Editors.Editor<T>;
 	}
 
-	export interface OnBeforeEditCellEventData<T extends SlickData> {
+	export interface OnBeforeEditCellEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 		item: T;
 		column: Column<T>;
 	}
 
-	export interface OnCellChangeEventData<T extends SlickData> {
+	export interface OnCellChangeEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 		item: T;
 	}
 
-	export interface OnColumnsResizedEventData {
+	export interface OnColumnsResizedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnColumnsReorderedEventData {
+	export interface OnColumnsReorderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnValidationErrorEventData<T extends SlickData> {
+	export interface OnValidationErrorEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		editor: Editors.Editor<T>;
 		cellNode: HTMLElement;
 		validationResults: ValidateResults;
@@ -1253,92 +1257,91 @@ declare module Slick {
 		column: Column<T>;
 	}
 
-	export interface OnAddNewRowEventData<T extends SlickData> {
+	export interface OnAddNewRowEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		item: T;
 		column: Column<T>;
 	}
 
-	export interface OnKeyDownEventData {
+	export interface OnKeyDownEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnContextMenuEventData {
+	export interface OnContextMenuEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnDblClickEventData {
+	export interface OnDblClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnClickEventData {
+	export interface OnClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		row: number;
 		cell: number;
 	}
 
-	export interface OnMouseLeaveEventData {
+	export interface OnMouseLeaveEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnMouseEnterEventData {
+	export interface OnMouseEnterEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
-	export interface OnBeforeHeaderRowCellDestroyEventData<T extends SlickData> {
+	export interface OnBeforeHeaderRowCellDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderRowCellRenderedEventData<T extends SlickData> {
+	export interface OnHeaderRowCellRenderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnBeforeHeaderCellDestroyEventData<T extends SlickData> {
+	export interface OnBeforeHeaderCellDestroyEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement; // todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderCellRenderedEventData<T extends SlickData> {
+	export interface OnHeaderCellRenderedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		node: HTMLElement;	// todo: might be JQuery instance
 		column: Column<T>;
 	}
 
-	export interface OnHeaderClickEventData<T extends SlickData> {
+	export interface OnHeaderClickEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	export interface OnHeaderContextMenuEventData<T extends SlickData> {
+	export interface OnHeaderContextMenuEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	export interface OnHeaderMouseEventData<T extends SlickData> {
+	export interface OnHeaderMouseEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		column: Column<T>;
 	}
 
-	// todo: merge with existing column definition
-	export interface Column<T extends SlickData> {
-		sortCol?: Column<T>;
-		sortAsc?: boolean;
-	}
-
-	export interface OnSortEventData<T extends SlickData> {
+	export interface OnSortEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		multiColumnSort: boolean;
-		sortCol?: Column<T>;
-		sortCols: Column<T>[];
-		sortAsc?: boolean;
+		sortCol?: SortColumn<T>;
+		sortCols?: SortColumn<T>[];
+		sortAsc: boolean;
 	}
 
-	export interface OnScrollEventData {
+	export interface OnScrollEventArgs<T extends SlickData> extends GridEventArgs<T> {
 		scrollLeft: number;
 		scrollTop: number;
 	}
 
-	export interface OnViewportChangedEventData {
+	export interface OnViewportChangedEventArgs<T extends SlickData> extends GridEventArgs<T> {
 
 	}
 
+	export interface SortColumn<T extends SlickData> {
+		sortCol: Column<T>;
+		sortAsc: boolean;
+	}
+
 	export interface Cell {
 		row: number;
 		cell: number;
@@ -1449,7 +1452,7 @@ declare module Slick {
 		}
 	}
 
-	export interface Formatter<T extends Slick.SlickData> {
+	export interface Formatter<T extends SlickData> {
         (row: number, cell: number, value: any, columnDef: Column<T>, dataContext: SlickData): string;
 	}
 

slickgrid/slick.headerbuttons.d.ts

@@ -24,7 +24,7 @@ declare module Slick {
         tooltip?: string;
     }
 
-    export interface OnCommandEventData<T extends SlickData> {
+    export interface OnCommandEventArgs<T extends SlickData> {
         grid: Grid<T>;
         column: Column<T>;
         command: string;
@@ -35,7 +35,7 @@ declare module Slick {
 
         export class HeaderButtons<T extends SlickData> extends Plugin<T> {
             constructor();
-            public onCommand: Event<OnCommandEventData<T>>;
+            public onCommand: Event<OnCommandEventArgs<T>>;
         }
     }
 }