Merge branch 'master' into lodash

2026-09-09 11:13:57 +08:00 · 2013-11-10 20:07:23 -05:00
parent e7ff6e84c6 f272d21fed
commit 11f72ba7f1
426 changed files with 22531 additions and 4555 deletions
@@ -1,4 +1,4 @@
-DefinitelyTyped [![Build Status](https://travis-ci.org/borisyankov/DefinitelyTyped.png?branch=master)](https://travis-ci.org/borisyankov/DefinitelyTyped)
+DefinitelyTyped [![Build Status](https://travis-ci.org/borisyankov/DefinitelyTyped.png?branch=master)](https://travis-ci.org/borisyankov/DefinitelyTyped)
 ===============

 The repository for *high quality* TypeScript type definitions.
@@ -49,6 +49,8 @@ List of Definitions
 * [CodeMirror](http://codemirror.net) (by [François de Campredon](https://github.com/fdecampredon))
 * [Commander](http://github.com/visionmedia/commander.js) (by [Marcelo Dezem](https://github.com/mdezem))
 * [d3.js](http://d3js.org/) (from TypeScript samples)
+* [dhtmlxGantt](http://dhtmlx.com/docs/products/dhtmlxGantt) (by [Maksim Kozhukh](http://github.com/mkozhukh))
+* [dhtmlxScheduler](http://dhtmlx.com/docs/products/dhtmlxScheduler) (by [Maksim Kozhukh](http://github.com/mkozhukh))
 * [docCookies](https://developer.mozilla.org/en-US/docs/Web/API/document.cookie) (by [Jon Egerton](https://github.com/jonegerton))
 * [domo](http://domo-js.com/) (by [Steve Fenton](https://github.com/Steve-Fenton))
 * [dust](http://linkedin.github.com/dustjs) (by [Marcelo Dezem](https://github.com/mdezem))
@@ -66,14 +68,17 @@ List of Definitions
 * [Firebase](https://www.firebase.com/docs/javascript/firebase) (by [Vincent Bortone](https://github.com/vbortone))
 * [Firefox](https://developer.mozilla.org/en-US/docs/Web/API) (by [vvakame](https://github.com/vvakame))
 * [FlexSlider](http://www.woothemes.com/flexslider/) (by [Diullei Gomes](https://github.com/Diullei))
+* [Flight by Twitter](http://flightjs.github.com/flight/) (by [Jonathan Hedrén](https://github.com/jonathanhedren))
 * [Foundation](http://foundation.zurb.com/) (by [Boris Yankov](https://github.com/borisyankov))
 * [FPSMeter](http://darsa.in/fpsmeter/) (by [Aaron Lampros](https://github.com/alampros))
 * [FullCalendar](http://arshaw.com/fullcalendar/) (by [Neil Stalker](https://github.com/nestalk))
 * [Gamepad](http://www.w3.org/TR/gamepad/) (by [Kon](http://phyzkit.net/))
+* [Giraffe](https://github.com/barc/backbone.giraffe) (by [Matt McCray](https://github.com/darthapo))
 * [glDatePicker](http://glad.github.com/glDatePicker/) (by [Dániel Tar](https://github.com/qcz))
 * [GoJS](http://gojs.net/) (by [Barbara Duckworth](https://github.com/barbara42))
+* [Greasemonkey](http://www.greasespot.net/) (by [Kota Saito](https://github.com/kotas))
 * [GreenSock Animation Platform (GSAP)](http://www.greensock.com/get-started-js/) (by [Robert S.](https://github.com/codeBelt))
-* [Grunt JS](http://gruntjs.com/) (by [Basarat Ali Syed](https://github.com/basarat))
+* [Grunt JS](http://gruntjs.com/) (by [Jeff May](https://github.com/jeffmay) and [Basarat Ali Syed](https://github.com/basarat))
 * [Google API Client](https://code.google.com/p/google-api-javascript-client/) (by [Frank M](https://github.com/sgtfrankieboy))
 * [Google App Engine Channel API](https://developers.google.com/appengine/docs/java/channel/javascript) (by [vvakame](https://github.com/vvakame))
 * [GoogleMaps](https://developers.google.com/maps/) (by [Esben Nepper](https://github.com/eNepper))
@@ -90,7 +95,6 @@ List of Definitions
 * [i18next](http://i18next.com/) (by [Maarten Docter](https://github.com/mdocter))
 * [iCheck](http://damirfoy.com/iCheck/) (by [Dániel Tar](https://github.com/qcz))
 * [Impress.js](https://github.com/bartaz/impress.js) (by [Boris Yankov](https://github.com/borisyankov))
-* [Intl](http://www.ecma-international.org/ecma-402/1.0/) (by [Jeffery Grajkowski](http://github.com/pushplay))
 * [iScroll](http://cubiq.org/iscroll-4) (by [Boris Yankov](https://github.com/borisyankov) and [Christiaan Rakowski](https://github.com/csrakowski))
 * [jake](https://github.com/mde/jake) (by [Kon](http://phyzkit.net/))
 * [Jasmine](http://pivotal.github.com/jasmine/) (by [Boris Yankov](https://github.com/borisyankov))
@@ -104,9 +108,10 @@ List of Definitions
 * [jQuery.areYouSure](https://github.com/codedance/jquery.AreYouSure) (by [Jon Egerton](https://github.com/jonegerton))
 * [jQuery.autosize](http://www.jacklmoore.com/autosize/) (by [Jack Moore](http://www.jacklmoore.com/))
 * [jQuery.BBQ](http://benalman.com/projects/jquery-bbq-plugin/) (by [Adam R. Smith](https://github.com/sunetos))
-* [jQuery.contextMenu](http://medialize.github.com/jQuery-contextMenu/) (by [Natan Vivo](https://github.com/nvivo/))
+* [jQuery.CLEditor](http://premiumsoftware.net/CLEditor) (by [Jeffery Grajkowski](https://github.com/pushplay))
 * [jQuery.clientSideLogging](https://github.com/remybach/jQuery.clientSideLogging/) (by [Diullei Gomes](https://github.com/diullei/))
 * [jQuery.Colorbox](http://www.jacklmoore.com/colorbox/) (by [Gidon Junge](https://github.com/gjunge))
+* [jQuery.contextMenu](http://medialize.github.com/jQuery-contextMenu/) (by [Natan Vivo](https://github.com/nvivo/))
 * [jQuery.Cookie](https://github.com/carhartl/jquery-cookie) (by [Roy Goode](https://github.com/RoyGoode))
 * [jQuery.Cycle](http://jquery.malsup.com/cycle/) (by [François Guillot](http://fguillot.developpez.com/))
 * [jQuery.dataTables](http://www.datatables.net) (by [Armin Sander](https://github.com/pragmatrix))
@@ -124,11 +129,13 @@ List of Definitions
 * [jquery.superLink](http://james.padolsey.com/demos/plugins/jQuery/superLink/superlink.jquery.js) (by [Blake Niemyjski](https://github.com/niemyjski))
 * [jQuery.timeago](http://timeago.yarp.com/) (by [François Guillot](http://fguillot.developpez.com/))
 * [jQuery.Timepicker](http://fgelinas.com/code/timepicker/) (by [Anwar Javed](https://github.com/anwarjaved))
+* [jQuery.Timer](http://jchavannes.com/jquery-timer/demo) (by [Joshua Strobl](https://github.com/JoshStrobl))
 * [jQuery.TinyCarousel](http://baijs.nl/tinycarousel/) (by [Christiaan Rakowski](https://github.com/csrakowski))
 * [jQuery.TinyScrollbar](http://baijs.nl/tinyscrollbar/) (by [Christiaan Rakowski](https://github.com/csrakowski))
 * [jQuery.Transit](http://ricostacruz.com/jquery.transit/) (by [MrBigDog2U](https://github.com/MrBigDog2U))
 * [jQuery.Validation](http://bassistance.de/jquery-plugins/jquery-plugin-validation/) (by [Boris Yankov](https://github.com/borisyankov))
 * [jQuery.Watermark](http://jquery-watermark.googlecode.com) (by [Anwar Javed](https://github.com/anwarjaved))
+* [jQuery.base64](https://github.com/yatt/jquery.base64) (by [Shinya Mochizuki](https://github.com/enrapt-mochizuki))
 * [jScrollPane](http://jscrollpane.kelvinluck.com) (by [Dániel Tar](https://github.com/qcz))
 * [JSDeferred](http://cho45.stfuawsc.com/jsdeferred/) (by [Daisuke Mino](https://github.com/minodisk))
 * [JSONEditorOnline](https://github.com/josdejong/jsoneditoronline) (by [Vincent Bortone](https://github.com/vbortone/))
@@ -141,7 +148,7 @@ List of Definitions
 * [Knockout.ES5](https://github.com/SteveSanderson/knockout-es5) (by [Sebastián Galiano](https://github.com/sgaliano))
 * [Knockout.Mapper](https://github.com/LucasLorentz/knockout.mapper) (by [Brandon Meyer](https://github.com/BMeyerKC))
 * [Knockout.Mapping](https://github.com/SteveSanderson/knockout.mapping) (by [Boris Yankov](https://github.com/borisyankov))
-* [Knockout.Postbox](https://github.com/rniemeyer/knockout-postbox) (by [Judah Gabriel](https://github.com/JudahGabriel))
+* [Knockout.Postbox](https://github.com/rniemeyer/knockout-postbox) (by [Judah Gabriel Himango](https://github.com/JudahGabriel))
 * [Knockout.Validation](https://github.com/ericmbarnard/Knockout-Validation) (by [Dan Ludwig](https://github.com/danludwig))
 * [Knockout.Viewmodel](http://coderenaissance.github.com/knockout.viewmodel/) (by [Oisin Grehan](https://github.com/oising))
 * [ko.editables](http://romanych.github.com/ko.editables/) (by [Oisin Grehan](https://github.com/oising))
@@ -167,7 +174,9 @@ List of Definitions
 * [node-ffi](https://github.com/rbranson/node-ffi) (by [Paul Loyd](https://github.com/loyd))
 * [node_zeromq](https://github.com/JustinTulloss/zeromq.node) (by [Dave McKeown](https://github.com/davemckeown))
 * [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) (by [Boris Yankov](https://github.com/borisyankov))
+* [NProgress](https://github.com/rstacruz/nprogress) (by [Judah Gabriel Himango](https://github.com/judahgabriel))
 * [Numeral.js](https://github.com/adamwdraper/Numeral-js) (by [Vincent Bortone](https://github.com/vbortone/))
+* [OpenLayers] (https://github.com/openlayers/openlayers) (by [Ilya Bolkhovsky](https://github.com/bolhovsky/))
 * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [PDF.js](https://github.com/mozilla/pdf.js) (by [Josh Baldwin](https://github.com/jbaldwin))
 * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto))
@@ -0,0 +1 @@
+tsc runner.ts --out runner.js --module commonjs
@@ -552,10 +552,11 @@ else if (typeof require === "function")
 else
        return null;
 })();
-/// <reference path='src/exec.ts' />
-/// <reference path='src/io.ts' />
 var DefinitelyTyped;
 (function (DefinitelyTyped) {
+    /// <reference path='../../node/node.d.ts' />
+    /// <reference path='src/exec.ts' />
+    /// <reference path='src/io.ts' />
    (function (TestManager) {
        var path = require('path');

@@ -586,6 +587,8 @@ var DefinitelyTyped;
                var command = 'node ./_infrastructure/tests/typescript/tsc.js --module commonjs ';
                if (IO.fileExists(tsfile + '.tscparams')) {
                    command += '@' + tsfile + '.tscparams';
+                } else {
+                    command += '--noImplicitAny';
                }
                Exec.exec(command, [tsfile], function (ExecResult) {
                    callback(ExecResult);
@@ -612,6 +615,10 @@ var DefinitelyTyped;
            return Typing;
        })();

+        /////////////////////////////////
+        // Given a document root + ts file pattern this class returns:
+        //         all the TS files OR just tests OR just definition files
+        /////////////////////////////////
        var FileHandler = (function () {
            function FileHandler(path, pattern) {
                this.path = path;
@@ -657,6 +664,10 @@ var DefinitelyTyped;
            return FileHandler;
        })();

+        /////////////////////////////////
+        // Timer.start starts a timer
+        // Timer.end stops the timer and sets asString to the pretty print value
+        /////////////////////////////////
        var Timer = (function () {
            function Timer() {
                this.time = 0;
@@ -686,6 +697,9 @@ var DefinitelyTyped;
            return Timer;
        })();

+        /////////////////////////////////
+        // All the common things that we pring are functions of this class
+        /////////////////////////////////
        var Print = (function () {
            function Print(version, typings, tsFiles) {
                this.version = version;
@@ -705,19 +719,19 @@ var DefinitelyTyped;
                this.out(' \33[36m\33[1mTypeScript files  :\33[0m ' + this.tsFiles + '\n');
            };

-            Print.prototype.printSyntaxChecking = function () {
+            Print.prototype.printSyntaxCheckingHeader = function () {
                this.out('============================ \33[34m\33[1mSyntax checking\33[0m ================================\n');
            };

-            Print.prototype.printTypingTests = function () {
+            Print.prototype.printTypingTestsHeader = function () {
                this.out('============================= \33[34m\33[1mTyping tests\33[0m ==================================\n');
            };

-            Print.prototype.printSuccess = function () {
+            Print.prototype.printSuccessCharacter = function () {
                this.out('\33[36m\33[1m.\33[0m');
            };

-            Print.prototype.printFailure = function () {
+            Print.prototype.printFailureCharacter = function () {
                this.out('x');
            };

@@ -725,6 +739,23 @@ var DefinitelyTyped;
                this.out('-----------------------------------------------------------------------------\n');
            };

+            Print.prototype.printBoldDiv = function () {
+                this.out('=============================================================================\n');
+            };
+
+            Print.prototype.printErrorsHeader = function () {
+                this.out('=============================================================================\n');
+                this.out('                    \33[34m\33[1mErrors in files\33[0m \n');
+                this.out('=============================================================================\n');
+            };
+
+            Print.prototype.printErrorsForFile = function (file) {
+                this.out('----------------- For file:' + file.formatName());
+                this.printBreak();
+                this.out(file.execResult.stderr);
+                this.printBreak();
+            };
+
            Print.prototype.printfilesWithSintaxErrorMessage = function () {
                this.out(' \33[36m\33[1mFiles with syntax error\33[0m\n');
            };
@@ -749,7 +780,7 @@ var DefinitelyTyped;
                this.out(' - \33[33m\33[1m' + file + '\33[0m\n');
            };

-            Print.prototype.breack = function () {
+            Print.prototype.printBreak = function () {
                this.out('\n');
            };

@@ -779,22 +810,30 @@ var DefinitelyTyped;
            return Print;
        })();

+        /////////////////////////////
+        // Represents the results of a test file execution
+        /////////////////////////////
        var File = (function () {
-            function File(name, hasError) {
-                this.name = name;
-                this.hasError = hasError;
+            function File(baseDir, filePathWithName, execResult) {
+                this.baseDir = baseDir;
+                this.filePathWithName = filePathWithName;
+                this.execResult = execResult;
            }
-            File.prototype.formatName = function (baseDir) {
-                var dirName = path.dirname(this.name.substr(baseDir.length + 1)).replace('\\', '/');
+            // From '/complete/path/to/file' to 'specfolder/specfile.d.ts'
+            File.prototype.formatName = function () {
+                var dirName = path.dirname(this.filePathWithName.substr(this.baseDir.length + 1)).replace('\\', '/');
                var dir = dirName.split('/')[0];
-                var file = path.basename(this.name, '.ts');
-                var ext = path.extname(this.name);
+                var file = path.basename(this.filePathWithName, '.ts');
+                var ext = path.extname(this.filePathWithName);

                return dir + ((dirName.split('/').length > 1) ? '/-/' : '/') + '\33[36m\33[1m' + file + '\33[0m' + ext;
            };
            return File;
        })();

+        /////////////////////////////
+        // Determine syntax errors in typings
+        /////////////////////////////
        var SyntaxChecking = (function () {
            function SyntaxChecking(fileHandler, out) {
                this.fileHandler = fileHandler;
@@ -806,7 +845,7 @@ var DefinitelyTyped;
                var list = [];

                for (var i = 0; i < this.files.length; i++) {
-                    if (this.files[i].hasError) {
+                    if (this.files[i].execResult.exitCode) {
                        list.push(this.files[i]);
                    }
                }
@@ -818,7 +857,7 @@ var DefinitelyTyped;
                var list = [];

                for (var i = 0; i < this.files.length; i++) {
-                    if (!this.files[i].hasError) {
+                    if (!this.files[i].execResult.exitCode) {
                        list.push(this.files[i]);
                    }
                }
@@ -843,7 +882,7 @@ var DefinitelyTyped;

                    for (var i = 0; i < this.getFailedFiles().length; i++) {
                        var errorFile = this.getFailedFiles()[i];
-                        this.out.printErrorFile(errorFile.formatName(this.fileHandler.path));
+                        this.out.printErrorFile(errorFile.formatName());
                    }
                }
            };
@@ -851,29 +890,26 @@ var DefinitelyTyped;
            SyntaxChecking.prototype.run = function (it, file, len, maxLen, callback) {
                var _this = this;
                if (!endsWith(file.toUpperCase(), '-TESTS.TS') && endsWith(file.toUpperCase(), '.TS') && file.indexOf('../_infrastructure') < 0) {
-                    new Test(file).run(function (o) {
-                        var failed = false;
-
-                        if (o.exitCode === 1) {
-                            _this.out.printFailure();
-                            failed = true;
+                    new Test(file).run(function (execResult) {
+                        if (execResult.exitCode === 1) {
+                            _this.out.printFailureCharacter();
                            len++;
                        } else {
-                            _this.out.printSuccess();
+                            _this.out.printSuccessCharacter();
                            len++;
                        }

-                        _this.files.push(new File(file, failed));
+                        _this.files.push(new File(_this.fileHandler.path, file, execResult));

                        if (len > maxLen) {
                            len = 0;
-                            _this.out.breack();
+                            _this.out.printBreak();
                        }

                        if (it.hasNext()) {
                            _this.run(it, it.next(), len, maxLen, callback);
                        } else {
-                            _this.out.breack();
+                            _this.out.printBreak();
                            _this.timer.end();
                            _this.printFailedFiles();
                            _this.printStats();
@@ -884,7 +920,7 @@ var DefinitelyTyped;
                } else if (it.hasNext()) {
                    this.run(it, it.next(), len, maxLen, callback);
                } else {
-                    this.out.breack();
+                    this.out.printBreak();
                    this.timer.end();
                    this.printStats();
                    this.printFailedFiles();
@@ -910,6 +946,9 @@ var DefinitelyTyped;
            return SyntaxChecking;
        })();

+        /////////////////////////////
+        // Determines errors in typing tests
+        /////////////////////////////
        var TestEval = (function () {
            function TestEval(fileHandler, out) {
                this.fileHandler = fileHandler;
@@ -921,7 +960,7 @@ var DefinitelyTyped;
                var list = [];

                for (var i = 0; i < this.files.length; i++) {
-                    if (this.files[i].hasError) {
+                    if (this.files[i].execResult.exitCode) {
                        list.push(this.files[i]);
                    }
                }
@@ -933,7 +972,7 @@ var DefinitelyTyped;
                var list = [];

                for (var i = 0; i < this.files.length; i++) {
-                    if (!this.files[i].hasError) {
+                    if (!this.files[i].execResult.exitCode) {
                        list.push(this.files[i]);
                    }
                }
@@ -958,7 +997,7 @@ var DefinitelyTyped;

                    for (var i = 0; i < this.getFailedFiles().length; i++) {
                        var errorFile = this.getFailedFiles()[i];
-                        this.out.printErrorFile(errorFile.formatName(this.fileHandler.path));
+                        this.out.printErrorFile(errorFile.formatName());
                    }
                }
            };
@@ -966,29 +1005,26 @@ var DefinitelyTyped;
            TestEval.prototype.run = function (it, file, len, maxLen, callback) {
                var _this = this;
                if (endsWith(file.toUpperCase(), '-TESTS.TS')) {
-                    new Test(file).run(function (o) {
-                        var failed = false;
-
-                        if (o.exitCode === 1) {
-                            _this.out.printFailure();
-                            failed = true;
+                    new Test(file).run(function (execResult) {
+                        if (execResult.exitCode === 1) {
+                            _this.out.printFailureCharacter();
                            len++;
                        } else {
-                            _this.out.printSuccess();
+                            _this.out.printSuccessCharacter();
                            len++;
                        }

-                        _this.files.push(new File(file, failed));
+                        _this.files.push(new File(_this.fileHandler.path, file, execResult));

                        if (len > maxLen) {
                            len = 0;
-                            _this.out.breack();
+                            _this.out.printBreak();
                        }

                        if (it.hasNext()) {
                            _this.run(it, it.next(), len, maxLen, callback);
                        } else {
-                            _this.out.breack();
+                            _this.out.printBreak();
                            _this.timer.end();
                            _this.printFailedFiles();
                            _this.printStats();
@@ -999,7 +1035,7 @@ var DefinitelyTyped;
                } else if (it.hasNext()) {
                    this.run(it, it.next(), len, maxLen, callback);
                } else {
-                    this.out.breack();
+                    this.out.printBreak();
                    this.timer.end();
                    this.printFailedFiles();
                    this.printStats();
@@ -1025,6 +1061,9 @@ var DefinitelyTyped;
            return TestEval;
        })();

+        /////////////////////////////////
+        // The main class to kick things off
+        /////////////////////////////////
        var TestRunner = (function () {
            function TestRunner(dtPath) {
                this.dtPath = dtPath;
@@ -1063,19 +1102,41 @@ var DefinitelyTyped;
                return count;
            };

+            TestRunner.prototype.printErrorsDetected = function () {
+                var _this = this;
+                this.out.printErrorsHeader();
+
+                var printErrorsForFileIfFound = function (file) {
+                    if (file.execResult.exitCode)
+                        _this.out.printErrorsForFile(file);
+                };
+
+                // sc errors:
+                this.sc.files.forEach(printErrorsForFileIfFound);
+                this.out.printBoldDiv();
+
+                // te errors:
+                this.te.files.forEach(printErrorsForFileIfFound);
+                this.out.printBoldDiv();
+            };
+
            TestRunner.prototype.run = function () {
                var _this = this;
                var timer = new Timer();
                timer.start();

                this.out.printHeader();
-                this.out.printSyntaxChecking();

+                // Run syntax tests
+                this.out.printSyntaxCheckingHeader();
                this.sc.start(function (syntaxFailedCount, syntaxTotal) {
-                    _this.out.printTypingTests();
+                    // Now run typing tests
+                    _this.out.printTypingTestsHeader();
                    _this.te.start(function (testFailedCount, testTotal) {
-                        var total = _this.printTypingsWithoutTest();
+                        // Get the tests without any typing and simultaneously print their names
+                        var totalTypingsWithoutTest = _this.printTypingsWithoutTest();

+                        // End total timer and print final messages
                        timer.end();

                        _this.out.printDiv();
@@ -1085,11 +1146,12 @@ var DefinitelyTyped;
                        _this.out.printElapsedTime(timer.asString, timer.time);
                        _this.out.printSyntaxErrorCount(syntaxFailedCount, syntaxTotal);
                        _this.out.printTestErrorCount(testFailedCount, testTotal);
-                        _this.out.printWithoutTestCount(total, _this.fh.allTypings().length);
+                        _this.out.printWithoutTestCount(totalTypingsWithoutTest, _this.fh.allTypings().length);

                        _this.out.printDiv();

                        if (syntaxFailedCount > 0 || testFailedCount > 0) {
+                            _this.printErrorsDetected();
                            process.exit(1);
                        }
                    });
@@ -83,22 +83,12 @@ declare class Enumerator {
    public item(): any;
    constructor (o: any);
 }
-declare function setTimeout(callback: () =>void , ms?: number);
-//declare var require: any;
-declare module process {
-    export var argv: string[];
-    export var platform: string;
-    export function on(event: string, handler: (any) => void ): void;
-    export module stdout {
-        export function write(str: string);
+
+// Missing in node definitions, but called in code below.
+interface NodeProcess {
+    mainModule: {
+        filename: string;
    }
-    export module stderr {
-        export function write(str: string);
-    }
-    export module mainModule {
-        export var filename: string;
-    }
-    export function exit(exitCode?: number);
 }

 var IO = (function() {
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -35,6 +35,7 @@ To avoid cluttering the list of suggestions as you type in your IDE, all interfa
 * `ng.cookies` for **ngCookies**
 * `ng.mock` for **ngMock**
 * `ng.resource` for **ngResource**
+* `ng.route` for **ngRoute**
 * `ng.sanitize` for **ngSanitize**

 **ngMockE2E** does not define a new namespace, but rather modifies some of **ng**'s interfaces.
@@ -0,0 +1,219 @@
+/// <reference path="angular-1.0.d.ts" />
+
+// issue: https://github.com/borisyankov/DefinitelyTyped/issues/369
+https://github.com/witoldsz/angular-http-auth/blob/master/src/angular-http-auth.js
+/**
+ * @license HTTP Auth Interceptor Module for AngularJS
+ * (c) 2012 Witold Szczerba
+ * License: MIT
+ */
+angular.module('http-auth-interceptor', [])
+
+    .provider('authService', function () {
+        /**
+         * Holds all the requests which failed due to 401 response,
+         * so they can be re-requested in future, once login is completed.
+         */
+        var buffer = [];
+
+        /**
+         * Required by HTTP interceptor.
+         * Function is attached to provider to be invisible for regular users of this service.
+         */
+        this.pushToBuffer = function (config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
+            buffer.push({
+                config: config,
+                deferred: deferred
+            });
+        }
+
+      this.$get = ['$rootScope', '$injector', <any>function ($rootScope: ng.IScope, $injector: ng.auto.IInjectorService) {
+            var $http: ng.IHttpService; //initialized later because of circular dependency problem
+            function retry(config: ng.IRequestConfig, deferred: ng.IDeferred<any>) {
+                $http = $http || $injector.get('$http');
+                $http(config).then(function (response) {
+                    deferred.resolve(response);
+                });
+            }
+            function retryAll() {
+                for (var i = 0; i < buffer.length; ++i) {
+                    retry(buffer[i].config, buffer[i].deferred);
+                }
+                buffer = [];
+            }
+
+          return {
+                loginConfirmed: function () {
+                    $rootScope.$broadcast('event:auth-loginConfirmed');
+                    retryAll();
+                }
+            }
+      }]
+  })
+
+/**
+ * $http interceptor.
+ * On 401 response - it stores the request and broadcasts 'event:angular-auth-loginRequired'.
+ */
+    .config(['$httpProvider', 'authServiceProvider', <any>function ($httpProvider: ng.IHttpProvider, authServiceProvider) {
+
+        var interceptor = ['$rootScope', '$q', <any>function ($rootScope: ng.IScope, $q: ng.IQService) {
+            function success(response: ng.IHttpPromiseCallbackArg<any>) {
+                return response;
+            }
+
+            function error(response: ng.IHttpPromiseCallbackArg<any>) {
+                if (response.status === 401) {
+                    var deferred = $q.defer();
+                    authServiceProvider.pushToBuffer(response.config, deferred);
+                    $rootScope.$broadcast('event:auth-loginRequired');
+                    return deferred.promise;
+                }
+                // otherwise
+                return $q.reject(response);
+            }
+
+          return function (promise: ng.IHttpPromise<any>) {
+                return promise.then(success, error);
+            }
+
+      }];
+        $httpProvider.responseInterceptors.push(interceptor);
+    }]);
+
+
+module HttpAndRegularPromiseTests {
+    interface Person {
+        firstName: string;
+        lastName: string;
+    }
+
+    interface ExpectedResponse extends Person { }
+
+    interface SomeControllerScope extends ng.IScope {
+        person: Person;
+        theAnswer: number;
+        letters: string[];
+    }
+
+    var someController: Function = ($scope: SomeControllerScope, $http: ng.IHttpService, $q: ng.IQService) => {
+        $http.get("http://somewhere/some/resource")
+            .success((data: ExpectedResponse) => {
+                $scope.person = data;
+            });
+
+        $http.get("http://somewhere/some/resource")
+            .then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
+                // typing lost, so something like
+                // var i: number = response.data
+                // would type check
+                $scope.person = response.data;
+            });
+
+        $http.get("http://somewhere/some/resource")
+            .then((response: ng.IHttpPromiseCallbackArg<ExpectedResponse>) => {
+                // typing lost, so something like
+                // var i: number = response.data
+                // would NOT type check
+                $scope.person = response.data;
+            });
+
+        var aPromise: ng.IPromise<Person> = $q.when({ firstName: "Jack", lastName: "Sparrow" });
+        aPromise.then((person: Person) => {
+            $scope.person = person;
+        });
+
+        var bPromise: ng.IPromise<number> = $q.when(42);
+        bPromise.then((answer: number) => {
+            $scope.theAnswer = answer;
+        });
+
+        var cPromise: ng.IPromise<string[]> = $q.when(["a", "b", "c"]);
+        cPromise.then((letters: string[]) => {
+            $scope.letters = letters;
+        });
+    }
+
+  // Test that we can pass around a type-checked success/error Promise Callback
+  var anotherController: Function = ($scope: SomeControllerScope, $http:
+        ng.IHttpService, $q: ng.IQService) => {
+
+        var buildFooData: Function = () => 42;
+
+        var doFoo: Function = (callback: ng.IHttpPromiseCallback<ExpectedResponse>) => {
+            $http.get('/foo', buildFooData())
+                .success(callback);
+        }
+
+    doFoo((data) => console.log(data));
+    }
+}
+
+// Test for AngularJS Syntax
+
+module My.Namespace {
+    export var x; // need to export something for module to kick in
+}
+
+// IModule Registering Test
+var mod = angular.module('tests', []);
+mod.controller('name', function ($scope: ng.IScope) { })
+mod.controller('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.controller(My.Namespace);
+mod.directive('name', <any>function ($scope: ng.IScope) { })
+mod.directive('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.directive(My.Namespace);
+mod.factory('name', function ($scope: ng.IScope) { })
+mod.factory('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.factory(My.Namespace);
+mod.filter('name', function ($scope: ng.IScope) { })
+mod.filter('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.filter(My.Namespace);
+mod.provider('name', function ($scope: ng.IScope) { })
+mod.provider('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.provider(My.Namespace);
+mod.service('name', function ($scope: ng.IScope) { })
+mod.service('name', ['$scope', <any>function ($scope: ng.IScope) { }])
+mod.service(My.Namespace);
+mod.constant('name', 23);
+mod.constant('name', "23");
+mod.constant(My.Namespace);
+mod.value('name', 23);
+mod.value('name', "23");
+mod.value(My.Namespace);
+
+// Promise signature tests
+var foo: ng.IPromise<number>;
+foo.then((x) => {
+    // x is inferred to be a number
+    return "asdf";
+}).then((x) => {
+    // x is inferred to be string
+    x.length;
+    return 123;
+}).then((x) => {
+    // x is infered to be a number
+    x.toFixed();
+    return;
+}).then((x) => {
+    // x is infered to be void
+    // Typescript will prevent you to actually use x as a local variable
+    // Try object:
+    return { a: 123 };
+}).then((x) => {
+    // Object is inferred here
+    x.a = 123;
+    //Try a promise
+    var y: ng.IPromise<number>;
+    return y;
+}).then((x) => {
+    // x is infered to be a number, which is the resolved value of a promise
+    x.toFixed();
+});
+
+
+// angular.element() tests
+var element = angular.element("div.myApp");
+var scope: ng.IScope = element.scope();
+
+
@@ -0,0 +1 @@
+""
@@ -0,0 +1,760 @@
+// Type definitions for Angular JS 1.0
+// Project: http://angularjs.org
+// Definitions by: Diego Vilar <http://github.com/diegovilar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+declare var angular: ng.IAngularStatic;
+
+// Support for painless dependency injection
+interface Function {
+    $inject:string[];
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// ng module (angular.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng {
+
+    // All service providers extend this interface
+    interface IServiceProvider {
+        $get(): any;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // AngularStatic
+    // see http://docs.angularjs.org/api
+    ///////////////////////////////////////////////////////////////////////////
+    interface IAngularStatic {
+        bind(context: any, fn: Function, ...args: any[]): Function;
+        bootstrap(element: string, modules?: any[]): auto.IInjectorService;
+        bootstrap(element: JQuery, modules?: any[]): auto.IInjectorService;
+        bootstrap(element: Element, modules?: any[]): auto.IInjectorService;
+        bootstrap(element: Document, modules?: any[]): auto.IInjectorService;
+        copy(source: any, destination?: any): any;
+        element: IAugmentedJQueryStatic;
+        equals(value1: any, value2: any): boolean;
+        extend(destination: any, ...sources: any[]): any;
+        forEach(obj: any, iterator: (value: any, key: any) => any, context?: any): any;
+        fromJson(json: string): any;
+        identity(arg?: any): any;
+        injector(modules?: any[]): auto.IInjectorService;
+        isArray(value: any): boolean;
+        isDate(value: any): boolean;
+        isDefined(value: any): boolean;
+        isElement(value: any): boolean;
+        isFunction(value: any): boolean;
+        isNumber(value: any): boolean;
+        isObject(value: any): boolean;
+        isString(value: any): boolean;
+        isUndefined(value: any): boolean;
+        lowercase(str: string): string;
+        /** construct your angular application
+		official docs: Interface for configuring angular modules.
+		see: http://docs.angularjs.org/api/angular.Module
+		*/
+        module(
+            /** name of your module you want to create */
+            name: string,
+            /** name of modules yours depends on */
+            requires?: string[],
+            configFunction?: any): IModule;
+        noop(...args: any[]): void;
+        toJson(obj: any, pretty?: boolean): string;
+        uppercase(str: string): string;
+        version: {
+            full: string;
+            major: number;
+            minor: number;
+            dot: number;
+            codename: string;
+        };
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Module
+    // see http://docs.angularjs.org/api/angular.Module
+    ///////////////////////////////////////////////////////////////////////////
+    interface IModule {
+        animation(name: string, animationFactory: Function): IModule;
+        animation(name: string, inlineAnnotadedFunction: any[]): IModule;
+        animation(object: Object): IModule;
+        /** configure existing services.
+		Use this method to register work which needs to be performed on module loading
+		 */
+        config(configFn: Function): IModule;
+        /** configure existing services.
+		Use this method to register work which needs to be performed on module loading
+		 */
+        config(inlineAnnotadedFunction: any[]): IModule;
+        constant(name: string, value: any): IModule;
+        constant(object: Object): IModule;
+        controller(name: string, controllerConstructor: Function): IModule;
+        controller(name: string, inlineAnnotadedConstructor: any[]): IModule;
+        controller(object : Object): IModule;
+        directive(name: string, directiveFactory: (...params:any[])=> IDirective): IModule;
+        directive(name: string, inlineAnnotadedFunction: any[]): IModule;
+        directive(object: Object): IModule;
+        factory(name: string, serviceFactoryFunction: Function): IModule;
+        factory(name: string, inlineAnnotadedFunction: any[]): IModule;
+        factory(object: Object): IModule;
+        filter(name: string, filterFactoryFunction: Function): IModule;
+        filter(name: string, inlineAnnotadedFunction: any[]): IModule;
+        filter(object: Object): IModule;
+        provider(name: string, serviceProviderConstructor: Function): IModule;
+        provider(name: string, inlineAnnotadedConstructor: any[]): IModule;
+        provider(object: Object): IModule;
+        run(initializationFunction: Function): IModule;
+        run(inlineAnnotadedFunction: any[]): IModule;
+        service(name: string, serviceConstructor: Function): IModule;
+        service(name: string, inlineAnnotadedConstructor: any[]): IModule;
+        service(object: Object): IModule;
+        value(name: string, value: any): IModule;
+        value(object: Object): IModule;
+
+        // Properties
+        name: string;
+        requires: string[];
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Attributes
+    // see http://docs.angularjs.org/api/ng.$compile.directive.Attributes
+    ///////////////////////////////////////////////////////////////////////////
+    interface IAttributes {
+        $set(name: string, value: any): void;
+        $observe(name: string, fn:(value?:any)=>any):void;
+        $attr: any;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // FormController
+    // see http://docs.angularjs.org/api/ng.directive:form.FormController
+    ///////////////////////////////////////////////////////////////////////////
+    interface IFormController {
+        $pristine: boolean;
+        $dirty: boolean;
+        $valid: boolean;
+        $invalid: boolean;
+        $error: any;
+        $setDirty(): void;
+        $setPristine(): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // NgModelController
+    // see http://docs.angularjs.org/api/ng.directive:ngModel.NgModelController
+    ///////////////////////////////////////////////////////////////////////////
+    interface INgModelController {
+        $render(): void;
+        $setValidity(validationErrorKey: string, isValid: boolean): void;
+        $setViewValue(value: string): void;
+
+        // XXX Not sure about the types here. Documentation states it's a string, but
+        // I've seen it receiving other types throughout the code.
+        // Falling back to any for now.
+        $viewValue: any;
+
+        // XXX Same as avove
+        $modelValue: any;
+
+        $parsers: IModelParser[];
+        $formatters: IModelFormatter[];
+        $error: any;
+        $pristine: boolean;
+        $dirty: boolean;
+        $valid: boolean;
+        $invalid: boolean;
+    }
+
+    interface IModelParser {
+        (value: any): any;
+    }
+
+    interface IModelFormatter {
+        (value: any): any;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Scope
+    // see http://docs.angularjs.org/api/ng.$rootScope.Scope
+    ///////////////////////////////////////////////////////////////////////////
+    interface IScope {
+        $apply(): any;
+        $apply(exp: string): any;
+        $apply(exp: (scope: IScope) => any): any;
+
+        $broadcast(name: string, ...args: any[]): IAngularEvent;
+        $destroy(): void;
+        $digest(): void;
+        $emit(name: string, ...args: any[]): IAngularEvent;
+
+        // Documentation says exp is optional, but actual implementaton counts on it
+        $eval(expression: string): any;
+        $eval(expression: (scope: IScope) => any): any;
+
+        // Documentation says exp is optional, but actual implementaton counts on it
+        $evalAsync(expression: string): void;
+        $evalAsync(expression: (scope: IScope) => any): void;
+
+        // Defaults to false by the implementation checking strategy
+        $new(isolate?: boolean): IScope;
+
+        $on(name: string, listener: (event: IAngularEvent, ...args: any[]) => any): Function;
+
+        $watch(watchExpression: string, listener?: string, objectEquality?: boolean): Function;
+        $watch(watchExpression: string, listener?: (newValue: any, oldValue: any, scope: IScope) => any, objectEquality?: boolean): Function;
+        $watch(watchExpression: (scope: IScope) => any, listener?: string, objectEquality?: boolean): Function;
+        $watch(watchExpression: (scope: IScope) => any, listener?: (newValue: any, oldValue: any, scope: IScope) => any, objectEquality?: boolean): Function;
+
+        $watchCollection(watchExpression: string, listener: (newValue: any, oldValue: any, scope: IScope) => any): Function;
+        $watchCollection(watchExpression: (scope: IScope) => any, listener: (newValue: any, oldValue: any, scope: IScope) => any): Function;
+
+        $parent: IScope;
+
+        $id: number;
+
+        // Hidden members
+        $$isolateBindings: any;
+        $$phase: any;
+    }
+
+    interface IAngularEvent {
+        targetScope: IScope;
+        currentScope: IScope;
+        name: string;
+        preventDefault: Function;
+        defaultPrevented: boolean;
+
+        // Available only events that were $emit-ted
+        stopPropagation?: Function;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // WindowService
+    // see http://docs.angularjs.org/api/ng.$window
+    ///////////////////////////////////////////////////////////////////////////
+    interface IWindowService extends Window {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // BrowserService
+    // TODO undocumented, so we need to get it from the source code
+    ///////////////////////////////////////////////////////////////////////////
+    interface IBrowserService {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // TimeoutService
+    // see http://docs.angularjs.org/api/ng.$timeout
+    ///////////////////////////////////////////////////////////////////////////
+    interface ITimeoutService {
+        (func: Function, delay?: number, invokeApply?: boolean): IPromise<any>;
+        cancel(promise: IPromise<any>): boolean;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // FilterService
+    // see http://docs.angularjs.org/api/ng.$filter
+    // see http://docs.angularjs.org/api/ng.$filterProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IFilterService {
+        (name: string): Function;
+    }
+
+    interface IFilterProvider extends IServiceProvider {
+        register(name: string, filterFactory: Function): IServiceProvider;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // LocaleService
+    // see http://docs.angularjs.org/api/ng.$locale
+    ///////////////////////////////////////////////////////////////////////////
+    interface ILocaleService {
+        id: string;
+
+        // These are not documented
+        // Check angular's i18n files for exemples
+        NUMBER_FORMATS: ILocaleNumberFormatDescriptor;
+        DATETIME_FORMATS: ILocaleDateTimeFormatDescriptor;
+        pluralCat: (num: any) => string;
+    }
+
+    interface ILocaleNumberFormatDescriptor {
+        DECIMAL_SEP: string;
+        GROUP_SEP: string;
+        PATTERNS: ILocaleNumberPatternDescriptor[];
+        CURRENCY_SYM: string;
+    }
+
+    interface ILocaleNumberPatternDescriptor {
+        minInt: number;
+        minFrac: number;
+        maxFrac: number;
+        posPre: string;
+        posSuf: string;
+        negPre: string;
+        negSuf: string;
+        gSize: number;
+        lgSize: number;
+    }
+
+    interface ILocaleDateTimeFormatDescriptor {
+        MONTH: string[];
+        SHORTMONTH: string[];
+        DAY: string[];
+        SHORTDAY: string[];
+        AMPMS: string[];
+        medium: string;
+        short: string;
+        fullDate: string;
+        longDate: string;
+        mediumDate: string;
+        shortDate: string;
+        mediumTime: string;
+        shortTime: string;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // LogService
+    // see http://docs.angularjs.org/api/ng.$log
+    ///////////////////////////////////////////////////////////////////////////
+    interface ILogService {
+        debug: ILogCall;
+        error: ILogCall;
+        info: ILogCall;
+        log: ILogCall;
+        warn: ILogCall;
+    }
+
+    // We define this as separete interface so we can reopen it later for
+    // the ngMock module.
+    interface ILogCall {
+        (...args: any[]): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ParseService
+    // see http://docs.angularjs.org/api/ng.$parse
+    ///////////////////////////////////////////////////////////////////////////
+    interface IParseService {
+        (expression: string): ICompiledExpression;
+    }
+
+    interface ICompiledExpression {
+        (context: any, locals?: any): any;
+
+        // If value is not provided, undefined is gonna be used since the implementation
+        // does not check the parameter. Let's force a value for consistency. If consumer
+        // whants to undefine it, pass the undefined value explicitly.
+        assign(context: any, value: any): any;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // LocationService
+    // see http://docs.angularjs.org/api/ng.$location
+    // see http://docs.angularjs.org/api/ng.$locationProvider
+    // see http://docs.angularjs.org/guide/dev_guide.services.$location
+    ///////////////////////////////////////////////////////////////////////////
+    interface ILocationService {
+        absUrl(): string;
+        hash(): string;
+        hash(newHash: string): ILocationService;
+        host(): string;
+        path(): string;
+        path(newPath: string): ILocationService;
+        port(): number;
+        protocol(): string;
+        replace(): ILocationService;
+        search(): any;
+        search(parametersMap: any): ILocationService;
+        search(parameter: string, parameterValue: any): ILocationService;
+        url(): string;
+        url(url: string): ILocationService;
+    }
+
+    interface ILocationProvider extends IServiceProvider {
+        hashPrefix(): string;
+        hashPrefix(prefix: string): ILocationProvider;
+        html5Mode(): boolean;
+
+        // Documentation states that parameter is string, but
+        // implementation tests it as boolean, which makes more sense
+        // since this is a toggler
+        html5Mode(active: boolean): ILocationProvider;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // DocumentService
+    // see http://docs.angularjs.org/api/ng.$document
+    ///////////////////////////////////////////////////////////////////////////
+    interface IDocumentService extends Document {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ExceptionHandlerService
+    // see http://docs.angularjs.org/api/ng.$exceptionHandler
+    ///////////////////////////////////////////////////////////////////////////
+    interface IExceptionHandlerService {
+        (exception: Error, cause?: string): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RootElementService
+    // see http://docs.angularjs.org/api/ng.$rootElement
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRootElementService extends JQuery {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // QService
+    // see http://docs.angularjs.org/api/ng.$q
+    ///////////////////////////////////////////////////////////////////////////
+    interface IQService {
+        all(promises: IPromise<any>[]): IPromise<any[]>;
+        defer<T>(): IDeferred<T>;
+        reject(reason?: any): IPromise<void>;
+        when<T>(value: T): IPromise<T>;
+    }
+
+    interface IPromise<T> {
+        then<TResult>(successCallback: (promiseValue: T) => IHttpPromise<TResult>, errorCallback?: (reason: any) => any): IPromise<TResult>;
+        then<TResult>(successCallback: (promiseValue: T) => IPromise<TResult>, errorCallback?: (reason: any) => any): IPromise<TResult>;
+        then<TResult>(successCallback: (promiseValue: T) => TResult, errorCallback?: (reason: any) => TResult): IPromise<TResult>;
+    }
+
+    interface IDeferred<T> {
+        resolve(value?: T): void;
+        reject(reason?: any): void;
+        promise: IPromise<T>;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // AnchorScrollService
+    // see http://docs.angularjs.org/api/ng.$anchorScroll
+    ///////////////////////////////////////////////////////////////////////////
+    interface IAnchorScrollService {
+        (): void;
+    }
+
+    interface IAnchorScrollProvider extends IServiceProvider {
+        disableAutoScrolling(): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // CacheFactoryService
+    // see http://docs.angularjs.org/api/ng.$cacheFactory
+    ///////////////////////////////////////////////////////////////////////////
+    interface ICacheFactoryService {
+        // Lets not foce the optionsMap to have the capacity member. Even though
+        // it's the ONLY option considered by the implementation today, a consumer
+        // might find it useful to associate some other options to the cache object.
+        //(cacheId: string, optionsMap?: { capacity: number; }): CacheObject;
+        (cacheId: string, optionsMap?: { capacity: number; }): ICacheObject;
+
+        // Methods bellow are not documented
+        info(): any;
+        get (cacheId: string): ICacheObject;
+    }
+
+    interface ICacheObject {
+        info(): {
+            id: string;
+            size: number;
+
+            // Not garanteed to have, since it's a non-mandatory option
+            //capacity: number;
+        };
+        put(key: string, value?: any): void;
+        get (key: string): any;
+        remove(key: string): void;
+        removeAll(): void;
+        destroy(): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // CompileService
+    // see http://docs.angularjs.org/api/ng.$compile
+    // see http://docs.angularjs.org/api/ng.$compileProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface ICompileService {
+        (element: string, transclude?: ITemplateLinkingFunction, maxPriority?: number): ITemplateLinkingFunction;
+        (element: Element, transclude?: ITemplateLinkingFunction, maxPriority?: number): ITemplateLinkingFunction;
+        (element: JQuery, transclude?: ITemplateLinkingFunction, maxPriority?: number): ITemplateLinkingFunction;
+    }
+
+    interface ICompileProvider extends IServiceProvider {
+        directive(name: string, directiveFactory: Function): ICompileProvider;
+
+        // Undocumented, but it is there...
+        directive(directivesMap: any): ICompileProvider;
+    }
+
+    interface ITemplateLinkingFunction {
+        // Let's hint but not force cloneAttachFn's signature
+        (scope: IScope, cloneAttachFn?: (clonedElement?: JQuery, scope?: IScope) => any): JQuery;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ControllerService
+    // see http://docs.angularjs.org/api/ng.$controller
+    // see http://docs.angularjs.org/api/ng.$controllerProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IControllerService {
+        // Although the documentation doesn't state this, locals are optional
+        (controllerConstructor: Function, locals?: any): any;
+        (controllerName: string, locals?: any): any;
+    }
+
+    interface IControllerProvider extends IServiceProvider {
+        register(name: string, controllerConstructor: Function): void;
+        register(name: string, dependencyAnnotadedConstructor: any[]): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // HttpService
+    // see http://docs.angularjs.org/api/ng.$http
+    ///////////////////////////////////////////////////////////////////////////
+    interface IHttpService {
+        // At least moethod and url must be provided...
+        (config: IRequestConfig): IHttpPromise<any>;
+        get (url: string, RequestConfig?: any): IHttpPromise<any>;
+        delete (url: string, RequestConfig?: any): IHttpPromise<any>;
+        head(url: string, RequestConfig?: any): IHttpPromise<any>;
+        jsonp(url: string, RequestConfig?: any): IHttpPromise<any>;
+        post(url: string, data: any, RequestConfig?: any): IHttpPromise<any>;
+        put(url: string, data: any, RequestConfig?: any): IHttpPromise<any>;
+        defaults: IRequestConfig;
+
+        // For debugging, BUT it is documented as public, so...
+        pendingRequests: any[];
+    }
+
+    // This is just for hinting.
+    // Some opetions might not be available depending on the request.
+    // see http://docs.angularjs.org/api/ng.$http#Usage for options explanations
+    interface IRequestConfig {
+        method: string;
+        url: string;
+        params?: any;
+
+        // XXX it has it's own structure...  perhaps we should define it in the future
+        headers?: any;
+
+        cache?: any;
+        timeout?: number;
+        withCredentials?: boolean;
+
+        // These accept multiple types, so let's defile them as any
+        data?: any;
+        transformRequest?: any;
+        transformResponse?: any;
+    }
+
+    interface IHttpPromiseCallback<T> {
+        (data: T, status: number, headers: (headerName: string) => string, config: IRequestConfig): void;
+    }
+
+    interface IHttpPromiseCallbackArg<T> {
+        data?: T;
+        status?: number;
+        headers?: (headerName: string) => string;
+        config?: IRequestConfig;
+    }
+
+    interface IHttpPromise<T> extends IPromise<T> {
+        success(callback: IHttpPromiseCallback<T>): IHttpPromise<T>;
+        error(callback: IHttpPromiseCallback<T>): IHttpPromise<T>;
+        then<TResult>(successCallback: (response: IHttpPromiseCallbackArg<T>) => TResult, errorCallback?: (response: IHttpPromiseCallbackArg<T>) => any): IPromise<TResult>;
+        then<TResult>(successCallback: (response: IHttpPromiseCallbackArg<T>) => IPromise<TResult>, errorCallback?: (response: IHttpPromiseCallbackArg<T>) => any): IPromise<TResult>;
+    }
+
+    interface IHttpProvider extends IServiceProvider {
+        defaults: IRequestConfig;
+        interceptors: any[];
+        responseInterceptors: any[];
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // HttpBackendService
+    // see http://docs.angularjs.org/api/ng.$httpBackend
+    // You should never need to use this service directly.
+    ///////////////////////////////////////////////////////////////////////////
+    interface IHttpBackendService {
+        // XXX Perhaps define callback signature in the future
+        (method: string, url: string, post?: any, callback?: Function, headers?: any, timeout?: number, withCredentials?: boolean): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // InterpolateService
+    // see http://docs.angularjs.org/api/ng.$interpolate
+    // see http://docs.angularjs.org/api/ng.$interpolateProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IInterpolateService {
+        (text: string, mustHaveExpression?: boolean): IInterpolationFunction;
+        endSymbol(): string;
+        startSymbol(): string;
+    }
+
+    interface IInterpolationFunction {
+        (context: any): string;
+    }
+
+    interface IInterpolateProvider extends IServiceProvider {
+        startSymbol(): string;
+        startSymbol(value: string): IInterpolateProvider;
+        endSymbol(): string;
+        endSymbol(value: string): IInterpolateProvider;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RouteParamsService
+    // see http://docs.angularjs.org/api/ng.$routeParams
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRouteParamsService {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // TemplateCacheService
+    // see http://docs.angularjs.org/api/ng.$templateCache
+    ///////////////////////////////////////////////////////////////////////////
+    interface ITemplateCacheService extends ICacheObject {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RootScopeService
+    // see http://docs.angularjs.org/api/ng.$rootScope
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRootScopeService extends IScope {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RouteService
+    // see http://docs.angularjs.org/api/ng.$route
+    // see http://docs.angularjs.org/api/ng.$routeProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRouteService {
+        reload(): void;
+        routes: any;
+
+        // May not always be available. For instance, current will not be available
+        // to a controller that was not initialized as a result of a route maching.
+        current?: ICurrentRoute;
+    }
+
+    // see http://docs.angularjs.org/api/ng.$routeProvider#when for options explanations
+    interface IRoute {
+        controller?: any;
+        name?: string;
+        template?: string;
+        templateUrl?: any;
+        resolve?: any;
+        redirectTo?: any;
+        reloadOnSearch?: boolean;
+    }
+
+    // see http://docs.angularjs.org/api/ng.$route#current
+    interface ICurrentRoute extends IRoute {
+        locals: {
+            $scope: IScope;
+            $template: string;
+        };
+
+        params: any;
+    }
+
+    interface IRouteProvider extends IServiceProvider {
+        otherwise(params: any): IRouteProvider;
+        when(path: string, route: IRoute): IRouteProvider;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Directive
+    // see http://docs.angularjs.org/api/ng.$compileProvider#directive
+    // and http://docs.angularjs.org/guide/directive
+    ///////////////////////////////////////////////////////////////////////////
+
+    interface IDirective{
+        priority?: number;
+        template?: any;
+        templateUrl?: any;
+        replace?: boolean;
+        transclude?: any;
+        restrict?: string;
+        scope?: any;
+        link?: Function;
+        compile?: Function;
+        controller?: any; 
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // angular.element
+    // when calling angular.element, angular returns a jQuery object,
+    // augmented with additional methods like e.g. scope.
+    // see: http://docs.angularjs.org/api/angular.element
+    ///////////////////////////////////////////////////////////////////////////
+    interface IAugmentedJQueryStatic extends JQueryStatic {
+        (selector: string, context?: any): IAugmentedJQuery;
+        (element: Element): IAugmentedJQuery;
+        (object: {}): IAugmentedJQuery;
+        (elementArray: Element[]): IAugmentedJQuery;
+        (object: JQuery): IAugmentedJQuery;
+        (func: Function): IAugmentedJQuery;
+        (array: any[]): IAugmentedJQuery;
+        (): IAugmentedJQuery;
+    }
+
+    interface IAugmentedJQuery extends JQuery {
+        // TODO: events, how to define?
+        //$destroy
+
+        find(selector: string): IAugmentedJQuery;
+        find(element: any): IAugmentedJQuery;
+        find(obj: JQuery): IAugmentedJQuery;
+
+        controller(name: string): any;
+        injector(): any;
+        scope(): IScope;
+
+        inheritedData(key: string, value: any): JQuery;
+        inheritedData(obj: { [key: string]: any; }): JQuery;
+        inheritedData(key?: string): any;
+
+
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // AUTO module (angular.js)
+    ///////////////////////////////////////////////////////////////////////////
+    export module auto {
+
+        ///////////////////////////////////////////////////////////////////////
+        // InjectorService
+        // see http://docs.angularjs.org/api/AUTO.$injector
+        ///////////////////////////////////////////////////////////////////////
+        interface IInjectorService {
+            annotate(fn: Function): string[];
+            annotate(inlineAnnotadedFunction: any[]): string[];
+            get (name: string): any;
+            instantiate(typeConstructor: Function, locals?: any): any;
+            invoke(func: Function, context?: any, locals?: any): any;
+        }
+
+        ///////////////////////////////////////////////////////////////////////
+        // ProvideService
+        // see http://docs.angularjs.org/api/AUTO.$provide
+        ///////////////////////////////////////////////////////////////////////
+        interface IProvideService {
+            // Documentation says it returns the registered instance, but actual
+            // implementation does not return anything.
+            // constant(name: string, value: any): any;
+            constant(name: string, value: any): void;
+
+            decorator(name: string, decorator: Function): void;
+            decorator(name: string, decoratorInline: any[]): void;
+            factory(name: string, serviceFactoryFunction: Function): ng.IServiceProvider;
+            provider(name: string, provider: ng.IServiceProvider): ng.IServiceProvider;
+            provider(name: string, serviceProviderConstructor: Function): ng.IServiceProvider;
+            service(name: string, constructor: Function): ng.IServiceProvider;
+            value(name: string, value: any): ng.IServiceProvider;
+        }
+
+    }
+
+}
@@ -0,0 +1,30 @@
+/// Type definitions for Angular JS 1.0 (ngCookies module)
+// Project: http://angularjs.org
+// Definitions by: Diego Vilar <http://github.com/diegovilar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="angular.d.ts" />
+
+///////////////////////////////////////////////////////////////////////////////
+// ngCookies module (angular-cookies.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng.cookies {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // CookieService
+    // see http://docs.angularjs.org/api/ngCookies.$cookies
+    ///////////////////////////////////////////////////////////////////////////
+    interface ICookiesService {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // CookieStoreService
+    // see http://docs.angularjs.org/api/ngCookies.$cookieStore
+    ///////////////////////////////////////////////////////////////////////////
+    interface ICookieStoreService {
+        get(key: string): any;
+        put(key: string, value: any): void;
+        remove(key: string): void;
+    }
+
+}
@@ -1,4 +1,4 @@
-/// Type definitions for Angular JS 1.0 (ngCookies module)
+/// Type definitions for Angular JS 1.2 (ngCookies module)
 // Project: http://angularjs.org
 // Definitions by: Diego Vilar <http://github.com/diegovilar>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -0,0 +1,150 @@
+// Type definitions for Angular JS 1.0 (ngMock, ngMockE2E module)
+// Project: http://angularjs.org
+// Definitions by: Diego Vilar <http://github.com/diegovilar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="angular.d.ts" />
+
+///////////////////////////////////////////////////////////////////////////////
+// functions attached to global object (window)
+///////////////////////////////////////////////////////////////////////////////
+declare var module: (...modules: any[]) => any;
+declare var inject: (...fns: Function[]) => any;
+
+///////////////////////////////////////////////////////////////////////////////
+// ngMock module (angular-mocks.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // AngularStatic
+    // We reopen it to add the MockStatic definition
+    ///////////////////////////////////////////////////////////////////////////
+    interface IAngularStatic {
+        mock: IMockStatic;
+    }
+
+    interface IMockStatic {
+        // see http://docs.angularjs.org/api/angular.mock.debug
+        debug(obj: any): string;
+                
+        // see http://docs.angularjs.org/api/angular.mock.inject
+        inject(...fns: Function[]): any;
+        
+        // see http://docs.angularjs.org/api/angular.mock.module
+        module(...modules: any[]): any;
+
+        // see http://docs.angularjs.org/api/angular.mock.TzDate
+        TzDate(offset: number, timestamp: number): Date;
+        TzDate(offset: number, timestamp: string): Date;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ExceptionHandlerService
+    // see http://docs.angularjs.org/api/ngMock.$exceptionHandler
+    // see http://docs.angularjs.org/api/ngMock.$exceptionHandlerProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IExceptionHandlerProvider extends IServiceProvider {
+        mode(mode: string): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // TimeoutService
+    // see http://docs.angularjs.org/api/ngMock.$timeout
+    // Augments the original service
+    ///////////////////////////////////////////////////////////////////////////
+    interface ITimeoutService {
+        flush(): void;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // LogService
+    // see http://docs.angularjs.org/api/ngMock.$log
+    // Augments the original service
+    ///////////////////////////////////////////////////////////////////////////
+    interface ILogService {
+        assertEmpty(): void;
+        reset(): void;
+    }
+
+    interface LogCall {
+        logs: string[];
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // HttpBackendService
+    // see http://docs.angularjs.org/api/ngMock.$httpBackend
+    ///////////////////////////////////////////////////////////////////////////
+    interface IHttpBackendService {
+        flush(count?: number): void;
+        resetExpectations(): void;
+        verifyNoOutstandingExpectation(): void;
+        verifyNoOutstandingRequest(): void;
+
+        expect(method: string, url: string, data?: any, headers?: any): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
+        expect(method: RegExp, url: string, data?: any, headers?: any): mock.IRequestHandler;
+        expect(method: RegExp, url: RegExp, data?: any, headers?: any): mock.IRequestHandler;      
+        
+        when(method: string, url: string, data?: string, headers?: any): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
+        when(method: string, url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
+        when(method: RegExp, url: string, data?: string, headers?: any): mock.IRequestHandler;
+        when(method: RegExp, url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
+        when(method: RegExp, url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
+        when(method: RegExp, url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;        
+                
+        expectDELETE(url: string, headers?: any): mock.IRequestHandler;
+        expectDELETE(url: RegExp, headers?: any): mock.IRequestHandler;
+        expectGET(url: string, headers?: any): mock.IRequestHandler;
+        expectGET(url: RegExp, headers?: any): mock.IRequestHandler;
+        expectHEAD(url: string, headers?: any): mock.IRequestHandler;
+        expectHEAD(url: RegExp, headers?: any): mock.IRequestHandler;
+        expectJSONP(url: string): mock.IRequestHandler;
+        expectJSONP(url: RegExp): mock.IRequestHandler;
+        expectPATCH(url: string, data?: any, headers?: any): mock.IRequestHandler;
+        expectPATCH(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
+        expectPOST(url: string, data?: any, headers?: any): mock.IRequestHandler;
+        expectPOST(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
+        expectPUT(url: string, data?: any, headers?: any): mock.IRequestHandler;
+        expectPUT(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
+
+        whenDELETE(url: string, headers?: any): mock.IRequestHandler;
+        whenDELETE(url: RegExp, headers?: any): mock.IRequestHandler;
+        whenGET(url: string, headers?: any): mock.IRequestHandler;
+        whenGET(url: RegExp, headers?: any): mock.IRequestHandler;
+        whenHEAD(url: string, headers?: any): mock.IRequestHandler;
+        whenHEAD(url: RegExp, headers?: any): mock.IRequestHandler;
+        whenJSONP(url: string): mock.IRequestHandler;
+        whenJSONP(url: RegExp): mock.IRequestHandler;
+        whenPATCH(url: string, data?: string, headers?: any): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
+        whenPATCH(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
+        whenPOST(url: string, data?: string, headers?: any): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
+        whenPOST(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
+        whenPUT(url: string, data?: string, headers?: any): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
+        whenPUT(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
+    }    
+
+    export module mock {
+        
+        // returned interface by the the mocked HttpBackendService expect/when methods
+        interface IRequestHandler {
+            respond(func: Function): void;        
+            respond(status: number, data?: any, headers?: any): void;
+            respond(data: any, headers?: any): void;
+
+            // Available wehn ngMockE2E is loaded
+            passThrough(): void;
+        }
+
+    }    
+
+}
@@ -0,0 +1,288 @@
+/// <reference path="angular-mocks.d.ts" />
+
+///////////////////////////////////////
+// IAngularStatic
+///////////////////////////////////////
+var angular: ng.IAngularStatic;
+var mock: ng.IMockStatic;
+
+mock = angular.mock;
+
+
+///////////////////////////////////////
+// IMockStatic
+///////////////////////////////////////
+var date: Date;
+
+mock.dump({ key: 'value' });
+
+mock.inject(
+    function () { return 1; },
+    function () { return 2; }
+    );
+
+mock.module('module1', 'module2');
+mock.module(
+    function () { return 1; },
+    function () { return 2; }
+    );
+mock.module({ module1: function () { return 1; } });
+
+date = mock.TzDate(-7, '2013-1-1T15:00:00Z');
+date = mock.TzDate(-8, 12345678);
+
+
+///////////////////////////////////////
+// IExceptionHandlerProvider
+///////////////////////////////////////
+var exceptionHandlerProvider: ng.IExceptionHandlerProvider;
+
+exceptionHandlerProvider.mode('log');
+
+
+///////////////////////////////////////
+// IExceptionHandlerProvider
+///////////////////////////////////////
+var timeoutService: ng.ITimeoutService;
+
+timeoutService.flush();
+timeoutService.flush(1234);
+timeoutService.flushNext();
+timeoutService.flushNext(1234);
+timeoutService.verifyNoPendingTasks();
+
+
+///////////////////////////////////////
+// ILogService, ILogCall
+///////////////////////////////////////
+var logService: ng.ILogService;
+var logCall: ng.ILogCall;
+var logs: string[];
+
+logService.assertEmpty();
+logService.reset();
+
+logCall = logService.debug;
+logCall = logService.error;
+logCall = logService.info;
+logCall = logService.log;
+logCall = logService.warn;
+
+logs = logCall.logs;
+
+
+///////////////////////////////////////
+// IHttpBackendService
+///////////////////////////////////////
+var httpBackendService: ng.IHttpBackendService;
+var requestHandler: ng.mock.IRequestHandler;
+
+httpBackendService.flush();
+httpBackendService.flush(1234);
+httpBackendService.resetExpectations();
+httpBackendService.verifyNoOutstandingExpectation();
+httpBackendService.verifyNoOutstandingRequest();
+
+requestHandler = httpBackendService.expect('GET', 'http://test.local');
+requestHandler = httpBackendService.expect('GET', 'http://test.local', 'response data');
+requestHandler = httpBackendService.expect('GET', 'http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', 'response data', function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', /response data/);
+requestHandler = httpBackendService.expect('GET', 'http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', /response data/, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', function (data: string): boolean { return true; }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', { key: 'value' });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', 'http://test.local', { key: 'value' }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', /test.local/);
+requestHandler = httpBackendService.expect('GET', /test.local/, 'response data');
+requestHandler = httpBackendService.expect('GET', /test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.expect('GET', /test.local/, 'response data', function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', /test.local/, /response data/);
+requestHandler = httpBackendService.expect('GET', /test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', /test.local/, /response data/, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', /test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', /test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', /test.local/, function (data: string): boolean { return true; }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.expect('GET', /test.local/, { key: 'value' });
+requestHandler = httpBackendService.expect('GET', /test.local/, { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.expect('GET', /test.local/, { key: 'value' }, function (headers: Object): boolean { return true; });
+
+requestHandler = httpBackendService.expectDELETE('http://test.local');
+requestHandler = httpBackendService.expectDELETE('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.expectDELETE(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.expectGET('http://test.local');
+requestHandler = httpBackendService.expectGET('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.expectGET(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.expectHEAD('http://test.local');
+requestHandler = httpBackendService.expectHEAD('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.expectHEAD(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.expectJSONP('http://test.local');
+requestHandler = httpBackendService.expectJSONP(/test.local/);
+
+requestHandler = httpBackendService.expectPATCH('http://test.local');
+requestHandler = httpBackendService.expectPATCH('http://test.local', 'response data');
+requestHandler = httpBackendService.expectPATCH('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPATCH('http://test.local', /response data/);
+requestHandler = httpBackendService.expectPATCH('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPATCH('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPATCH('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPATCH('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.expectPATCH('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.expectPATCH(/test.local/);
+requestHandler = httpBackendService.expectPATCH(/test.local/, 'response data');
+requestHandler = httpBackendService.expectPATCH(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPATCH(/test.local/, /response data/);
+requestHandler = httpBackendService.expectPATCH(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPATCH(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPATCH(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPATCH(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.expectPATCH(/test.local/, { key: 'value' }, { header: 'value' });
+
+requestHandler = httpBackendService.expectPOST('http://test.local');
+requestHandler = httpBackendService.expectPOST('http://test.local', 'response data');
+requestHandler = httpBackendService.expectPOST('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPOST('http://test.local', /response data/);
+requestHandler = httpBackendService.expectPOST('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPOST('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPOST('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPOST('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.expectPOST('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.expectPOST(/test.local/);
+requestHandler = httpBackendService.expectPOST(/test.local/, 'response data');
+requestHandler = httpBackendService.expectPOST(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPOST(/test.local/, /response data/);
+requestHandler = httpBackendService.expectPOST(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPOST(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPOST(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPOST(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.expectPOST(/test.local/, { key: 'value' }, { header: 'value' });
+
+requestHandler = httpBackendService.expectPUT('http://test.local');
+requestHandler = httpBackendService.expectPUT('http://test.local', 'response data');
+requestHandler = httpBackendService.expectPUT('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPUT('http://test.local', /response data/);
+requestHandler = httpBackendService.expectPUT('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPUT('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPUT('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPUT('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.expectPUT('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.expectPUT(/test.local/);
+requestHandler = httpBackendService.expectPUT(/test.local/, 'response data');
+requestHandler = httpBackendService.expectPUT(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.expectPUT(/test.local/, /response data/);
+requestHandler = httpBackendService.expectPUT(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.expectPUT(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.expectPUT(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.expectPUT(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.expectPUT(/test.local/, { key: 'value' }, { header: 'value' });
+
+requestHandler = httpBackendService.when('GET', 'http://test.local');
+requestHandler = httpBackendService.when('GET', 'http://test.local', 'response data');
+requestHandler = httpBackendService.when('GET', 'http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.when('GET', 'http://test.local', 'response data', function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', 'http://test.local', /response data/);
+requestHandler = httpBackendService.when('GET', 'http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.when('GET', 'http://test.local', /response data/, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', 'http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.when('GET', 'http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.when('GET', 'http://test.local', function (data: string): boolean { return true; }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', 'http://test.local', { key: 'value' });
+requestHandler = httpBackendService.when('GET', 'http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.when('GET', 'http://test.local', { key: 'value' }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', /test.local/);
+requestHandler = httpBackendService.when('GET', /test.local/, 'response data');
+requestHandler = httpBackendService.when('GET', /test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.when('GET', /test.local/, 'response data', function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', /test.local/, /response data/);
+requestHandler = httpBackendService.when('GET', /test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.when('GET', /test.local/, /response data/, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', /test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.when('GET', /test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.when('GET', /test.local/, function (data: string): boolean { return true; }, function (headers: Object): boolean { return true; });
+requestHandler = httpBackendService.when('GET', /test.local/, { key: 'value' });
+requestHandler = httpBackendService.when('GET', /test.local/, { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.when('GET', /test.local/, { key: 'value' }, function (headers: Object): boolean { return true; });
+
+requestHandler = httpBackendService.whenDELETE('http://test.local');
+requestHandler = httpBackendService.whenDELETE('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.whenDELETE(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.whenGET('http://test.local');
+requestHandler = httpBackendService.whenGET('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.whenGET(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.whenHEAD('http://test.local');
+requestHandler = httpBackendService.whenHEAD('http://test.local', { header: 'value' });
+requestHandler = httpBackendService.whenHEAD(/test.local/, { header: 'value' });
+requestHandler = httpBackendService.whenJSONP('http://test.local');
+requestHandler = httpBackendService.whenJSONP(/test.local/);
+
+requestHandler = httpBackendService.whenPATCH('http://test.local');
+requestHandler = httpBackendService.whenPATCH('http://test.local', 'response data');
+requestHandler = httpBackendService.whenPATCH('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPATCH('http://test.local', /response data/);
+requestHandler = httpBackendService.whenPATCH('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPATCH('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPATCH('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPATCH('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.whenPATCH('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.whenPATCH(/test.local/);
+requestHandler = httpBackendService.whenPATCH(/test.local/, 'response data');
+requestHandler = httpBackendService.whenPATCH(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPATCH(/test.local/, /response data/);
+requestHandler = httpBackendService.whenPATCH(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPATCH(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPATCH(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPATCH(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.whenPATCH(/test.local/, { key: 'value' }, { header: 'value' });
+
+requestHandler = httpBackendService.whenPOST('http://test.local');
+requestHandler = httpBackendService.whenPOST('http://test.local', 'response data');
+requestHandler = httpBackendService.whenPOST('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPOST('http://test.local', /response data/);
+requestHandler = httpBackendService.whenPOST('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPOST('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPOST('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPOST('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.whenPOST('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.whenPOST(/test.local/);
+requestHandler = httpBackendService.whenPOST(/test.local/, 'response data');
+requestHandler = httpBackendService.whenPOST(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPOST(/test.local/, /response data/);
+requestHandler = httpBackendService.whenPOST(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPOST(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPOST(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPOST(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.whenPOST(/test.local/, { key: 'value' }, { header: 'value' });
+
+requestHandler = httpBackendService.whenPUT('http://test.local');
+requestHandler = httpBackendService.whenPUT('http://test.local', 'response data');
+requestHandler = httpBackendService.whenPUT('http://test.local', 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPUT('http://test.local', /response data/);
+requestHandler = httpBackendService.whenPUT('http://test.local', /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPUT('http://test.local', function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPUT('http://test.local', function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPUT('http://test.local', { key: 'value' });
+requestHandler = httpBackendService.whenPUT('http://test.local', { key: 'value' }, { header: 'value' });
+requestHandler = httpBackendService.whenPUT(/test.local/);
+requestHandler = httpBackendService.whenPUT(/test.local/, 'response data');
+requestHandler = httpBackendService.whenPUT(/test.local/, 'response data', { header: 'value' });
+requestHandler = httpBackendService.whenPUT(/test.local/, /response data/);
+requestHandler = httpBackendService.whenPUT(/test.local/, /response data/, { header: 'value' });
+requestHandler = httpBackendService.whenPUT(/test.local/, function (data: string): boolean { return true; });
+requestHandler = httpBackendService.whenPUT(/test.local/, function (data: string): boolean { return true; }, { header: 'value' });
+requestHandler = httpBackendService.whenPUT(/test.local/, { key: 'value' });
+requestHandler = httpBackendService.whenPUT(/test.local/, { key: 'value' }, { header: 'value' });
+
+
+///////////////////////////////////////
+// IRequestHandler
+///////////////////////////////////////
+requestHandler.passThrough();
+requestHandler.respond(function () { });
+requestHandler.respond({ key: 'value' });
+requestHandler.respond({ key: 'value' }, { header: 'value' });
+requestHandler.respond(404);
+requestHandler.respond(404, { key: 'value' });
+requestHandler.respond(404, { key: 'value' }, { header: 'value' });
@@ -0,0 +1 @@
+""
@@ -1,9 +1,8 @@
-// Type definitions for Angular JS 1.0 (ngMock, ngMockE2E module)
+// Type definitions for Angular JS 1.2 (ngMock, ngMockE2E module)
 // Project: http://angularjs.org
 // Definitions by: Diego Vilar <http://github.com/diegovilar>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped

-
 /// <reference path="angular.d.ts" />

 ///////////////////////////////////////////////////////////////////////////////
@@ -26,14 +25,16 @@ declare module ng {
    }

    interface IMockStatic {
-        // see http://docs.angularjs.org/api/angular.mock.debug
-        debug(obj: any): string;
-                
+        // see http://docs.angularjs.org/api/angular.mock.dump
+        dump(obj: any): string;
+
        // see http://docs.angularjs.org/api/angular.mock.inject
        inject(...fns: Function[]): any;
-        
+
        // see http://docs.angularjs.org/api/angular.mock.module
-        module(...modules: any[]): any;
+        module(...modules: string[]): any;
+        module(...modules: Function[]): any;
+        module(modules: Object): any;

        // see http://docs.angularjs.org/api/angular.mock.TzDate
        TzDate(offset: number, timestamp: number): Date;
@@ -55,7 +56,9 @@ declare module ng {
    // Augments the original service
    ///////////////////////////////////////////////////////////////////////////
    interface ITimeoutService {
-        flush(): void;
+        flush(delay?: number): void;
+        flushNext(expectedDelay?: number): void;
+        verifyNoPendingTasks(): void;
    }

    ///////////////////////////////////////////////////////////////////////////
@@ -68,7 +71,7 @@ declare module ng {
        reset(): void;
    }

-    interface LogCall {
+    interface ILogCall {
        logs: string[];
    }

@@ -82,62 +85,127 @@ declare module ng {
        verifyNoOutstandingExpectation(): void;
        verifyNoOutstandingRequest(): void;

-        expect(method: string, url: string, data?: any, headers?: any): mock.IRequestHandler;
-        expect(method: string, url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
-        expect(method: RegExp, url: string, data?: any, headers?: any): mock.IRequestHandler;
-        expect(method: RegExp, url: RegExp, data?: any, headers?: any): mock.IRequestHandler;      
-        
-        when(method: string, url: string, data?: string, headers?: any): mock.IRequestHandler;
-        when(method: string, url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
-        when(method: string, url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
-        when(method: string, url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
-        when(method: RegExp, url: string, data?: string, headers?: any): mock.IRequestHandler;
-        when(method: RegExp, url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
-        when(method: RegExp, url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
-        when(method: RegExp, url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;        
-                
-        expectDELETE(url: string, headers?: any): mock.IRequestHandler;
-        expectDELETE(url: RegExp, headers?: any): mock.IRequestHandler;
-        expectGET(url: string, headers?: any): mock.IRequestHandler;
-        expectGET(url: RegExp, headers?: any): mock.IRequestHandler;
-        expectHEAD(url: string, headers?: any): mock.IRequestHandler;
-        expectHEAD(url: RegExp, headers?: any): mock.IRequestHandler;
+        expect(method: string, url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: string, data?: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: string, data?: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: string, data?: (data: string) => boolean, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: string, data?: Object, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: (data: string) => boolean, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+        expect(method: string, url: RegExp, data?: Object, headers?: (object: Object) => boolean): mock.IRequestHandler;
+
+        expectDELETE(url: string, headers?: Object): mock.IRequestHandler;
+        expectDELETE(url: RegExp, headers?: Object): mock.IRequestHandler;
+        expectGET(url: string, headers?: Object): mock.IRequestHandler;
+        expectGET(url: RegExp, headers?: Object): mock.IRequestHandler;
+        expectHEAD(url: string, headers?: Object): mock.IRequestHandler;
+        expectHEAD(url: RegExp, headers?: Object): mock.IRequestHandler;
        expectJSONP(url: string): mock.IRequestHandler;
        expectJSONP(url: RegExp): mock.IRequestHandler;
-        expectPATCH(url: string, data?: any, headers?: any): mock.IRequestHandler;
-        expectPATCH(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
-        expectPOST(url: string, data?: any, headers?: any): mock.IRequestHandler;
-        expectPOST(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;
-        expectPUT(url: string, data?: any, headers?: any): mock.IRequestHandler;
-        expectPUT(url: RegExp, data?: any, headers?: any): mock.IRequestHandler;

-        whenDELETE(url: string, headers?: any): mock.IRequestHandler;
-        whenDELETE(url: RegExp, headers?: any): mock.IRequestHandler;
-        whenGET(url: string, headers?: any): mock.IRequestHandler;
-        whenGET(url: RegExp, headers?: any): mock.IRequestHandler;
-        whenHEAD(url: string, headers?: any): mock.IRequestHandler;
-        whenHEAD(url: RegExp, headers?: any): mock.IRequestHandler;
+        expectPATCH(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPATCH(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+
+        expectPOST(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPOST(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+
+        expectPUT(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        expectPUT(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+
+        when(method: string, url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: string, data?: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: string, data?: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: string, data?: (data: string) => boolean, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: string, data?: Object, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: (data: string) => boolean, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+        when(method: string, url: RegExp, data?: Object, headers?: (object: Object) => boolean): mock.IRequestHandler;
+
+        whenDELETE(url: string, headers?: Object): mock.IRequestHandler;
+        whenDELETE(url: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        whenDELETE(url: RegExp, headers?: Object): mock.IRequestHandler;
+        whenDELETE(url: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+
+        whenGET(url: string, headers?: Object): mock.IRequestHandler;
+        whenGET(url: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        whenGET(url: RegExp, headers?: Object): mock.IRequestHandler;
+        whenGET(url: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+
+        whenHEAD(url: string, headers?: Object): mock.IRequestHandler;
+        whenHEAD(url: string, headers?: (object: Object) => boolean): mock.IRequestHandler;
+        whenHEAD(url: RegExp, headers?: Object): mock.IRequestHandler;
+        whenHEAD(url: RegExp, headers?: (object: Object) => boolean): mock.IRequestHandler;
+
        whenJSONP(url: string): mock.IRequestHandler;
        whenJSONP(url: RegExp): mock.IRequestHandler;
-        whenPATCH(url: string, data?: string, headers?: any): mock.IRequestHandler;
-        whenPATCH(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
-        whenPATCH(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
-        whenPATCH(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
-        whenPOST(url: string, data?: string, headers?: any): mock.IRequestHandler;
-        whenPOST(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
-        whenPOST(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
-        whenPOST(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
-        whenPUT(url: string, data?: string, headers?: any): mock.IRequestHandler;
-        whenPUT(url: RegExp, data?: string, headers?: any): mock.IRequestHandler;
-        whenPUT(url: string, data?: RegExp, headers?: any): mock.IRequestHandler;
-        whenPUT(url: RegExp, data?: RegExp, headers?: any): mock.IRequestHandler;
-    }    
+
+        whenPATCH(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPATCH(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+
+        whenPOST(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPOST(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+
+        whenPUT(url: string, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: string, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: string, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: string, data?: Object, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: string, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: RegExp, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: (data: string) => boolean, headers?: Object): mock.IRequestHandler;
+        whenPUT(url: RegExp, data?: Object, headers?: Object): mock.IRequestHandler;
+    }

    export module mock {
-        
+
        // returned interface by the the mocked HttpBackendService expect/when methods
        interface IRequestHandler {
-            respond(func: Function): void;        
+            respond(func: Function): void;
            respond(status: number, data?: any, headers?: any): void;
            respond(data: any, headers?: any): void;

@@ -145,6 +213,6 @@ declare module ng {
            passThrough(): void;
        }

-    }    
+    }

 }
@@ -0,0 +1 @@
+""
@@ -0,0 +1,82 @@
+// Type definitions for Angular JS 1.0 (ngResource module)
+// Project: http://angularjs.org
+// Definitions by: Diego Vilar <http://github.com/diegovilar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="angular.d.ts" />
+
+
+///////////////////////////////////////////////////////////////////////////////
+// ngResource module (angular-resource.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng.resource {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // ResourceService
+    // see http://docs.angularjs.org/api/ngResource.$resource
+    // Most part of the following definitions were achieved by analyzing the
+    // actual implementation, since the documentation doesn't seem to cover
+    // that deeply.
+    ///////////////////////////////////////////////////////////////////////////
+    interface IResourceService {
+    	(url: string, paramDefaults?: any,
+			/** example:  {update: { method: 'PUT' }, delete: deleteDescriptor } 
+			where deleteDescriptor : IActionDescriptor */
+			actionDescriptors?: any): IResourceClass;
+    }
+
+    // Just a reference to facilitate describing new actions
+    interface IActionDescriptor {
+        method: string;
+        isArray?: boolean;
+        params?: any;
+        headers?: any;
+    }
+
+    // Baseclass for everyresource with default actions.
+    // If you define your new actions for the resource, you will need
+    // to extend this interface and typecast the ResourceClass to it.
+    interface IResourceClass {
+        get: IActionCall;
+        save: IActionCall;
+        query: IActionCall;
+        remove: IActionCall;
+        delete: IActionCall;
+    }
+
+    // In case of passing the first argument as anything but a function,
+    // it's gonna be considered data if the action method is POST, PUT or
+    // PATCH (in other words, methods with body). Otherwise, it's going
+    // to be considered as parameters to the request.
+    interface IActionCall {
+        (): IResource;
+        (dataOrParams: any): IResource;
+        (dataOrParams: any, success: Function): IResource;
+        (success: Function, error?: Function): IResource;
+        (params: any, data: any, success?: Function, error?: Function): IResource;
+    }
+
+    interface IResource {
+        $save: IActionCall;
+        $remove: IActionCall;
+        $delete: IActionCall;
+
+        // No documented, but they are there, just as any custom action will be
+        $query: IActionCall;
+        $get: IActionCall;
+    }
+
+    /** when creating a resource factory via IModule.factory */
+    interface IResourceServiceFactoryFunction {
+        ($resource: ng.resource.IResourceService): ng.resource.IResourceClass;
+    }
+}
+
+/** extensions to base ng based on using angular-resource */
+declare module ng {
+
+    interface IModule {
+        /** creating a resource service factory */
+        factory(name: string, resourceServiceFactoryFunction: ng.resource.IResourceServiceFactoryFunction): IModule;
+    }
+}
@@ -0,0 +1,74 @@
+/// <reference path="angular-resource.d.ts" />
+
+///////////////////////////////////////
+// IActionDescriptor
+///////////////////////////////////////
+var actionDescriptor: ng.resource.IActionDescriptor;
+
+actionDescriptor.headers = { header: 'value' };
+actionDescriptor.isArray = true;
+actionDescriptor.method = 'method action';
+actionDescriptor.params = { key: 'value' };
+
+
+///////////////////////////////////////
+// IResourceClass
+///////////////////////////////////////
+var resourceClass: ng.resource.IResourceClass;
+var resource: ng.resource.IResource;
+
+resource = resourceClass.delete();
+resource = resourceClass.delete({ key: 'value' });
+resource = resourceClass.delete({ key: 'value' }, function () { });
+resource = resourceClass.delete(function () { });
+resource = resourceClass.delete(function () { }, function () { });
+resource = resourceClass.delete({ key: 'value' }, { key: 'value' });
+resource = resourceClass.delete({ key: 'value' }, { key: 'value' }, function () { });
+resource = resourceClass.delete({ key: 'value' }, { key: 'value' }, function () { }, function () { });
+
+resource = resourceClass.get();
+resource = resourceClass.get({ key: 'value' });
+resource = resourceClass.get({ key: 'value' }, function () { });
+resource = resourceClass.get(function () { });
+resource = resourceClass.get(function () { }, function () { });
+resource = resourceClass.get({ key: 'value' }, { key: 'value' });
+resource = resourceClass.get({ key: 'value' }, { key: 'value' }, function () { });
+resource = resourceClass.get({ key: 'value' }, { key: 'value' }, function () { }, function () { });
+
+resource = resourceClass.query();
+resource = resourceClass.query({ key: 'value' });
+resource = resourceClass.query({ key: 'value' }, function () { });
+resource = resourceClass.query(function () { });
+resource = resourceClass.query(function () { }, function () { });
+resource = resourceClass.query({ key: 'value' }, { key: 'value' });
+resource = resourceClass.query({ key: 'value' }, { key: 'value' }, function () { });
+resource = resourceClass.query({ key: 'value' }, { key: 'value' }, function () { }, function () { });
+
+resource = resourceClass.remove();
+resource = resourceClass.remove({ key: 'value' });
+resource = resourceClass.remove({ key: 'value' }, function () { });
+resource = resourceClass.remove(function () { });
+resource = resourceClass.remove(function () { }, function () { });
+resource = resourceClass.remove({ key: 'value' }, { key: 'value' });
+resource = resourceClass.remove({ key: 'value' }, { key: 'value' }, function () { });
+resource = resourceClass.remove({ key: 'value' }, { key: 'value' }, function () { }, function () { });
+
+resource = resourceClass.save();
+resource = resourceClass.save({ key: 'value' });
+resource = resourceClass.save({ key: 'value' }, function () { });
+resource = resourceClass.save(function () { });
+resource = resourceClass.save(function () { }, function () { });
+resource = resourceClass.save({ key: 'value' }, { key: 'value' });
+resource = resourceClass.save({ key: 'value' }, { key: 'value' }, function () { });
+resource = resourceClass.save({ key: 'value' }, { key: 'value' }, function () { }, function () { });
+
+
+///////////////////////////////////////
+// IModule
+///////////////////////////////////////
+var mod: ng.IModule;
+var resourceServiceFactoryFunction: ng.resource.IResourceServiceFactoryFunction;
+var resourceService: ng.resource.IResourceService;
+
+resourceServiceFactoryFunction = function (resourceService) { return resourceClass };
+mod = mod.factory('factory name', resourceServiceFactoryFunction);
@@ -1,4 +1,4 @@
-// Type definitions for Angular JS 1.0 (ngResource module)
+// Type definitions for Angular JS 1.2 (ngResource module)
 // Project: http://angularjs.org
 // Definitions by: Diego Vilar <http://github.com/diegovilar>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -19,10 +19,10 @@ declare module ng.resource {
    // that deeply.
    ///////////////////////////////////////////////////////////////////////////
    interface IResourceService {
-    	(url: string, paramDefaults?: any,
-			/** example:  {update: { method: 'PUT' }, delete: deleteDescriptor } 
-			where deleteDescriptor : IActionDescriptor */
-			actionDescriptors?: any): IResourceClass;
+        (url: string, paramDefaults?: any,
+            /** example:  {update: { method: 'PUT' }, delete: deleteDescriptor }
+            where deleteDescriptor : IActionDescriptor */
+            actionDescriptors?: any): IResourceClass;
    }

    // Just a reference to facilitate describing new actions
@@ -0,0 +1,14 @@
+/// <reference path="angular-route.d.ts" />
+
+/**
+ * @license HTTP Auth Interceptor Module for AngularJS
+ * (c) 2013 Jonathan Park @ Daptiv Solutions Inc
+ * License: MIT
+ */
+
+declare var $routeProvider: ng.route.IRouteProvider;
+$routeProvider
+        .when('/projects/:projectId/dashboard',{
+            controller: ''
+        })
+        .otherwise({redirectTo: '/'});
@@ -0,0 +1,64 @@
+// Type definitions for Angular JS 1.2 (ngRoute module)
+// Project: http://angularjs.org
+// Definitions by: Jonathan Park
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="angular.d.ts" />
+
+
+///////////////////////////////////////////////////////////////////////////////
+// ngRoute module (angular-route.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng.route {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RouteParamsService
+    // see http://docs.angularjs.org/api/ngRoute.$routeParams
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRouteParamsService {}
+
+    ///////////////////////////////////////////////////////////////////////////
+    // RouteService
+    // see http://docs.angularjs.org/api/ngRoute.$route
+    // see http://docs.angularjs.org/api/ngRoute.$routeProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface IRouteService {
+        reload(): void;
+        routes: any;
+
+        // May not always be available. For instance, current will not be available
+        // to a controller that was not initialized as a result of a route maching.
+        current?: ICurrentRoute;
+    }
+
+    // see http://docs.angularjs.org/api/ngRoute.$routeProvider#when for options explanations
+    interface IRoute {
+        controller?: any;
+        controllerAs?: any;
+        name?: string;
+        template?: string;
+        templateUrl?: any;
+        resolve?: any;
+        redirectTo?: any;
+        reloadOnSearch?: boolean;
+    }
+
+    // see http://docs.angularjs.org/api/ng.$route#current
+    interface ICurrentRoute extends IRoute {
+        locals: {
+            $scope: IScope;
+            $template: string;
+        };
+
+        params: any;
+    }
+
+    interface IRouteProvider extends IServiceProvider {
+        otherwise(params: any): IRouteProvider;
+        /**
+         * This is a description
+         *
+         */
+        when(path: string, route: IRoute): IRouteProvider;
+    }
+}
@@ -0,0 +1,22 @@
+// Type definitions for Angular JS 1.0 (ngSanitize module)
+// Project: http://angularjs.org
+// Definitions by: Diego Vilar <http://github.com/diegovilar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="angular.d.ts" />
+
+///////////////////////////////////////////////////////////////////////////////
+// ngSanitize module (angular-sanitize.js)
+///////////////////////////////////////////////////////////////////////////////
+declare module ng.sanitize {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // SanitizeService
+    // see http://docs.angularjs.org/api/ngSanitize.$sanitize
+    ///////////////////////////////////////////////////////////////////////////
+    interface ISanitizeService {
+        (html: string): string;
+    }
+
+}
@@ -1,4 +1,4 @@
-// Type definitions for Angular JS 1.0 (ngSanitize module)
+// Type definitions for Angular JS 1.2 (ngSanitize module)
 // Project: http://angularjs.org
 // Definitions by: Diego Vilar <http://github.com/diegovilar>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -0,0 +1,155 @@
+// Type definitions for Angular Scenario Testing
+// Project: [http://angularjs.org]
+// Definitions by: [RomanoLindano]
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module angularScenario {
+    export interface AngularModel {
+        scenario: any;
+    }
+
+    export interface RunFunction {
+        (functionToRun: any): any;
+    }
+    export interface RunFunctionWithDescription {
+        (description: string, functionToRun: any): any;
+    }
+
+    export interface PauseFunction {
+        (): any;
+    }
+
+    export interface SleepFunction {
+        (seconds: number): any;
+    }
+
+    export interface Future {
+    }
+
+    export interface testWindow {
+        href(): Future;
+        path(): Future;
+        search(): Future;
+        hash(): Future;
+    }
+
+    export interface testLocation {
+        url(): Future;
+        path(): Future;
+        search(): Future;
+        hash(): Future;
+    }
+
+    export interface Browser {
+        navigateTo(url: string): void;
+        navigateTo(urlDescription: string, urlFunction: () => string): void;
+        reload(): void;
+        window(): testWindow;
+        location(): testLocation;
+    }    
+    
+    export interface Matchers {
+        toEqual(value: any): void;
+        toBe(value: any): void;    
+        toBeDefined(): void;    
+        toBeTruthy(): void;            
+        toBeFalsy(): void;    
+        toMatch(regularExpression: any): void;    
+        toBeNull(): void;    
+        toContain(value: any): void;
+        toBeLessThan(value: any): void;    
+        toBeGreaterThan(value: any): void;    
+    }
+
+    export interface CustomMatchers extends Matchers{        
+    }
+
+    export interface Expect extends CustomMatchers {        
+        not(): angularScenario.CustomMatchers;
+    }
+
+    export interface UsingFunction {
+        (selector: string, selectorDescription?: string): void;
+    }
+
+    export interface BindingFunction {
+        (bracketBindingExpression: string): Future;
+    }
+
+    export interface Input {
+        enter(value: any);
+        check(): any;
+        select(radioButtonValue: any): any;
+        val(): Future;
+    }
+
+    export interface Repeater {
+        count(): Future;
+        row(index: number): Future;
+        column(ngBindingExpression: string): Future;
+    }
+
+    export interface Select {
+        option(value: any): any;
+        option(...listOfValues: any[]): any;
+    }    
+
+    export interface Element {
+        count(): Future;
+        click(): any;
+        query(callback: (selectedDOMElements: any[], callbackWhenDone: (objNull: any, futureValue: any) => any) =>any): any;
+        val(): Future;
+        text(): Future;
+        html(): Future;
+        height(): Future;
+        innerHeight(): Future;
+        outerHeight(): Future;
+        width(): Future;
+        innerWidth(): Future;
+        outerWidth(): Future;
+        position(): Future;
+        scrollLeft(): Future;
+        scrollTop(): Future;
+        offset(): Future;
+        
+        val(value: any): void;
+        text(value: any): void;
+        html(value: any): void;
+        height(value: any): void;
+        innerHeight(value: any): void;
+        outerHeight(value: any): void;
+        width(value: any): void;
+        innerWidth(value: any): void;
+        outerWidth(value: any): void;
+        position(value: any): void;
+        scrollLeft(value: any): void;
+        scrollTop(value: any): void;
+        offset(value: any): void;
+
+        attr(key: any): Future;
+        prop(key: any): Future;
+        css(key: any): Future;
+
+        attr(key: any, value: any): void;
+        prop(key: any, value: any): void;
+        css(key: any, value: any): void;
+    }
+}
+
+declare var describe: angularScenario.RunFunctionWithDescription;
+declare var xdescribe: angularScenario.RunFunctionWithDescription;
+declare var beforeEach: angularScenario.RunFunction;
+declare var afterEach: angularScenario.RunFunction;
+declare var it: angularScenario.RunFunctionWithDescription;
+declare var xit: angularScenario.RunFunctionWithDescription;
+declare var pause: angularScenario.PauseFunction;
+declare var sleep: angularScenario.SleepFunction;
+declare function browser(): angularScenario.Browser;
+declare function expect(expectation: angularScenario.Future): angularScenario.Expect;
+declare var using: angularScenario.UsingFunction;
+declare var binding: angularScenario.BindingFunction;
+declare function input(ngModelBinding: string): angularScenario.Input;
+declare function repeater(selector: string, repeaterDescription?: string): angularScenario.Repeater;
+declare function select(ngModelBinding: string): angularScenario.Select;
+declare function element(selector: string, elementDescription?: string): angularScenario.Element;
+declare var angular: angularScenario.AngularModel;
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -182,6 +182,7 @@ mod.value('name', 23);
 mod.value('name', "23");
 mod.value(My.Namespace);

+
 // Promise signature tests
 var foo: ng.IPromise<number>;
 foo.then((x) => {
@@ -217,3 +218,17 @@ var element = angular.element("div.myApp");
 var scope: ng.IScope = element.scope();


+
+function test_IAttributes(attributes: ng.IAttributes){
+    return attributes;
+}
+
+test_IAttributes({
+    $addClass: function (classVal){},
+    $removeClass: function(classVal){},
+    $set: function(key, value){},
+    $observe: function(name, fn){
+        return fn;
+    },
+    $attr: {}
+});
@@ -0,0 +1 @@
+""
@@ -81,11 +81,11 @@ declare module ng {
        animation(name: string, animationFactory: Function): IModule;
        animation(name: string, inlineAnnotadedFunction: any[]): IModule;
        animation(object: Object): IModule;
-        /** configure existing services.  
+        /** configure existing services.
 		Use this method to register work which needs to be performed on module loading
 		 */
        config(configFn: Function): IModule;
-        /** configure existing services.  
+        /** configure existing services.
 		Use this method to register work which needs to be performed on module loading
 		 */
        config(inlineAnnotadedFunction: any[]): IModule;
@@ -94,9 +94,9 @@ declare module ng {
        controller(name: string, controllerConstructor: Function): IModule;
        controller(name: string, inlineAnnotadedConstructor: any[]): IModule;
        controller(object : Object): IModule;
-        directive(name: string, directiveFactory: (...params:any[])=> IDirective): IModule;
+        directive(name: string, directiveFactory: Function): IModule;
        directive(name: string, inlineAnnotadedFunction: any[]): IModule;
-        directive(object: Object): IModule;        
+        directive(object: Object): IModule;
        factory(name: string, serviceFactoryFunction: Function): IModule;
        factory(name: string, inlineAnnotadedFunction: any[]): IModule;
        factory(object: Object): IModule;
@@ -124,9 +124,33 @@ declare module ng {
    // see http://docs.angularjs.org/api/ng.$compile.directive.Attributes
    ///////////////////////////////////////////////////////////////////////////
    interface IAttributes {
-        $set(name: string, value: any): void;
-        $observe(name: string, fn:(value?:any)=>any):void;
-        $attr: any;
+    	// this is necessary to be able to access the scoped attributes. it's not very elegant
+    	// because you have to use attrs['foo'] instead of attrs.foo but I don't know of a better way
+    	// this should really be limited to return string but it creates this problem: http://stackoverflow.com/q/17201854/165656
+    	[name: string]: any; 
+    	
+        // Adds the CSS class value specified by the classVal parameter to the 
+        // element. If animations are enabled then an animation will be triggered 
+        // for the class addition.
+        $addClass(classVal: string): void;
+
+        // Removes the CSS class value specified by the classVal parameter from the 
+        // element. If animations are enabled then an animation will be triggered for 
+        // the class removal.
+        $removeClass(classVal: string): void;
+
+        // Set DOM element attribute value.
+        $set(key: string, value: any): void;
+
+        // Observes an interpolated attribute.
+        // The observer function will be invoked once during the next $digest 
+        // following compilation. The observer is then invoked whenever the 
+        // interpolated value changes.
+        $observe(name: string, fn:(value?:any)=>any): Function;
+
+        // A map of DOM element attribute names to the normalized name. This is needed 
+        // to do reverse lookup from normalized name back to actual name.
+        $attr: Object;
    }

    ///////////////////////////////////////////////////////////////////////////
@@ -139,6 +163,8 @@ declare module ng {
        $valid: boolean;
        $invalid: boolean;
        $error: any;
+        $addControl(control: ng.INgModelController): void;
+        $removeControl(control: ng.INgModelController): void;
        $setDirty(): void;
        $setPristine(): void;
    }
@@ -150,14 +176,11 @@ declare module ng {
    interface INgModelController {
        $render(): void;
        $setValidity(validationErrorKey: string, isValid: boolean): void;
-        $setViewValue(value: string): void;
-
-        // XXX Not sure about the types here. Documentation states it's a string, but
-        // I've seen it receiving other types throughout the code.
-        // Falling back to any for now.
+        // Documentation states viewValue and modelValue to be a string but other
+        // types do work and it's common to use them.
+        $setViewValue(value: any): void;
        $viewValue: any;

-        // XXX Same as avove
        $modelValue: any;

        $parsers: IModelParser[];
@@ -192,8 +215,8 @@ declare module ng {
        $emit(name: string, ...args: any[]): IAngularEvent;

        // Documentation says exp is optional, but actual implementaton counts on it
-        $eval(expression: string): any;
-        $eval(expression: (scope: IScope) => any): any;
+        $eval(expression: string, args?: Object): any;
+        $eval(expression: (scope: IScope) => any, args?: Object): any;

        // Documentation says exp is optional, but actual implementaton counts on it
        $evalAsync(expression: string): void;
@@ -215,7 +238,7 @@ declare module ng {
        $parent: IScope;

        $id: number;
-        
+
        // Hidden members
        $$isolateBindings: any;
        $$phase: any;
@@ -253,6 +276,15 @@ declare module ng {
        cancel(promise: IPromise<any>): boolean;
    }

+    ///////////////////////////////////////////////////////////////////////////
+    // IntervalService
+    // see http://docs.angularjs.org/api/ng.$interval
+    ///////////////////////////////////////////////////////////////////////////
+    interface IIntervalService {
+        (func: Function, delay: number, count?: number, invokeApply?: boolean): IPromise<any>;
+        cancel(promise: IPromise<any>): boolean;
+    }
+
    ///////////////////////////////////////////////////////////////////////////
    // FilterService
    // see http://docs.angularjs.org/api/ng.$filter
@@ -605,12 +637,6 @@ declare module ng {
        endSymbol(value: string): IInterpolateProvider;
    }

-    ///////////////////////////////////////////////////////////////////////////
-    // RouteParamsService
-    // see http://docs.angularjs.org/api/ng.$routeParams
-    ///////////////////////////////////////////////////////////////////////////
-    interface IRouteParamsService {}
-
    ///////////////////////////////////////////////////////////////////////////
    // TemplateCacheService
    // see http://docs.angularjs.org/api/ng.$templateCache
@@ -624,45 +650,58 @@ declare module ng {
    interface IRootScopeService extends IScope {}

    ///////////////////////////////////////////////////////////////////////////
-    // RouteService
-    // see http://docs.angularjs.org/api/ng.$route
-    // see http://docs.angularjs.org/api/ng.$routeProvider
+    // SCEService
+    // see http://docs.angularjs.org/api/ng.$sce
    ///////////////////////////////////////////////////////////////////////////
-    interface IRouteService {
-        reload(): void;
-        routes: any;
+	interface ISCEService {
+		getTrusted(type: string, mayBeTrusted: any): any;
+		getTrustedCss(value: any): any;
+		getTrustedHtml(value: any): any;
+		getTrustedJs(value: any): any;
+		getTrustedResourceUrl(value: any): any;
+		getTrustedUrl(value: any): any;
+		parse(type: string, expression: string): (context: any, locals: any) => any;
+		parseAsCss(expression: string): (context: any, locals: any) => any;
+		parseAsHtml(expression: string): (context: any, locals: any) => any;
+		parseAsJs(expression: string): (context: any, locals: any) => any;
+		parseAsResourceUrl(expression: string): (context: any, locals: any) => any;
+		parseAsUrl(expression: string): (context: any, locals: any) => any;
+		trustAs(type: string, value: any): any;
+		trustAsHtml(value: any): any;
+		trustAsJs(value: any): any;
+		trustAsResourceUrl(value: any): any;
+		trustAsUrl(value: any): any;
+		isEnabled(): boolean;
+	}

-        // May not always be available. For instance, current will not be available
-        // to a controller that was not initialized as a result of a route maching.
-        current?: ICurrentRoute;
+    ///////////////////////////////////////////////////////////////////////////
+    // SCEProvider
+    // see http://docs.angularjs.org/api/ng.$sceProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface ISCEProvider extends IServiceProvider {
+        enabled(value: boolean): void;
    }

-    // see http://docs.angularjs.org/api/ng.$routeProvider#when for options explanations
-    interface IRoute {
-        controller?: any;
-        name?: string;
-        template?: string;
-        templateUrl?: any;
-        resolve?: any;
-        redirectTo?: any;
-        reloadOnSearch?: boolean;
+    ///////////////////////////////////////////////////////////////////////////
+    // SCEDelegateService
+    // see http://docs.angularjs.org/api/ng.$sceDelegate
+    ///////////////////////////////////////////////////////////////////////////
+    interface ISCEDelegateService {
+        getTrusted(type: string, mayBeTrusted: any): any;
+        trustAs(type: string, value: any): any;
+        valueOf(value: any): any;
    }

-    // see http://docs.angularjs.org/api/ng.$route#current
-    interface ICurrentRoute extends IRoute {
-        locals: {
-            $scope: IScope;
-            $template: string;
-        };
-
-        params: any;
+	
+    ///////////////////////////////////////////////////////////////////////////
+    // SCEDelegateProvider
+    // see http://docs.angularjs.org/api/ng.$sceDelegateProvider
+    ///////////////////////////////////////////////////////////////////////////
+    interface ISCEDelegateProvider extends IServiceProvider {
+        resourceUrlBlacklist(blacklist: any[]): void;
+        resourceUrlWhitelist(whitelist: any[]): void;
    }
-
-    interface IRouteProvider extends IServiceProvider {
-        otherwise(params: any): IRouteProvider;
-        when(path: string, route: IRoute): IRouteProvider;
-    }
-    
+	
    ///////////////////////////////////////////////////////////////////////////
    // Directive
    // see http://docs.angularjs.org/api/ng.$compileProvider#directive
@@ -670,16 +709,29 @@ declare module ng {
    ///////////////////////////////////////////////////////////////////////////

    interface IDirective{
+        compile?:
+            (templateElement: any,
+            templateAttributes: IAttributes,
+            transclude: (scope: IScope, cloneLinkingFn: Function) => void
+            ) => any;
+        controller?: any;
+        controllerAs?: string;
+        link?:
+            (scope: IScope,
+            instanceElement: any,
+            instanceAttributes: IAttributes,
+            controller: any
+            ) => void;
+        name?: string;
        priority?: number;
-        template?: string;
-        templateUrl?: string;
        replace?: boolean;
-        transclude?: any;
+        require?: any;
        restrict?: string;
        scope?: any;
-        link?: Function;
-        compile?: Function;
-        controller?: Function;
+        template?: any;
+        templateUrl?: any;
+        terminal?: boolean;
+        transclude?: any;
    }

    ///////////////////////////////////////////////////////////////////////////
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -13,7 +13,7 @@ interface AsyncWorker<T> { (task: T, callback: Function): void; }
 interface AsyncQueue<T> {
    length(): number;
    concurrency: number;
-    push(task: T, callback: AsyncMultipleResultsCallback<T>): void;
+    push(task: T, callback?: AsyncMultipleResultsCallback<T>): void;
    saturated: AsyncMultipleResultsCallback<T>;
    empty: AsyncMultipleResultsCallback<T>;
    drain: AsyncMultipleResultsCallback<T>;
@@ -79,4 +79,4 @@ declare var async: Async;

 declare module "async" {
 	export = async;
-}
+}
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -67,16 +67,16 @@ declare module Backbone {
    }

    class Events {
-        on(eventName: any, callback?: (...args: any[]) => void , context?: any): any;
-        off(eventName?: string, callback?: (...args: any[]) => void , context?: any): any;
+        on(eventName: any, callback?: Function, context?: any): any;
+        off(eventName?: string, callback?: Function, context?: any): any;
        trigger(eventName: string, ...args: any[]): any;
-        bind(eventName: string, callback: (...args: any[]) => void , context?: any): any;
-        unbind(eventName?: string, callback?: (...args: any[]) => void , context?: any): any;
+        bind(eventName: string, callback: Function, context?: any): any;
+        unbind(eventName?: string, callback?: Function, context?: any): any;

-        once(events: string, callback: (...args: any[]) => void , context?: any): any;
-        listenTo(object: any, events: string, callback: (...args: any[]) => void ): any;
-        listenToOnce(object: any, events: string, callback: (...args: any[]) => void ): any;
-        stopListening(object?: any, events?: string, callback?: (...args: any[]) => void ): any;
+        once(events: string, callback: Function, context?: any): any;
+        listenTo(object: any, events: string, callback: Function): any;
+        listenToOnce(object: any, events: string, callback: Function): any;
+        stopListening(object?: any, events?: string, callback?: Function): any;
    }

    class ModelBase extends Events {
@@ -248,7 +248,7 @@ declare module Backbone {

        constructor(options?: RouterOptions);
        initialize(options?: RouterOptions);
-        route(route: string, name: string, callback?: (...parameter: any[]) => void );
+        route(route: string, name: string, callback?: Function);
        navigate(fragment: string, options?: NavigateOptions);
        navigate(fragment: string, trigger?: boolean);

@@ -269,7 +269,7 @@ declare module Backbone {
        getHash(window?: Window): string;
        getFragment(fragment?: string, forcePushState?: boolean): string;
        stop(): void;
-        route(route: string, callback: (...args: any[]) => void );
+        route(route: string, callback: Function);
        checkUrl(e?: any): void;
        loadUrl(fragmentOverride: string): boolean;
        navigate(fragment: string, options?: any);
@@ -339,4 +339,3 @@ declare module Backbone {

    function setDomLibrary(jQueryNew);
 }
-
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -1,4 +1,4 @@
-// Type definitions for bootstrap.datepicker
+// Type definitions for bootstrap.datepicker
 // Project: https://github.com/eternicode/bootstrap-datepicker
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -24,4 +24,10 @@ interface JQuery {
    datepicker(methodName: string): JQuery;
    datepicker(methodName: string, params: any): JQuery;
    datepicker(options: DatepickerOptions): JQuery;
-}
+
+    off(events?: "changeDate", selector?: any, handler?: (eventObject: any) => any): JQuery;
+
+    on(events: "changeDate", selector?: string, data?: any, handler?: (eventObject: any) => any): JQuery;
+    on(events: "changeDate", selector?: string, handler?: (eventObject: any) => any): JQuery;
+    on(events: "changeDate", handler?: (eventObject: any) => any): JQuery;
+}
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -9,25 +9,25 @@ declare module "browser-harness" {
    import events = require("events");

    interface HarnessEvents extends events.NodeEventEmitter {
-        once(event: string, listener: (driver: Driver) => void);
-        once(event: 'ready', listener: (driver: Driver) => void);
+        once(event: string, listener: (driver: Driver) => void): events.NodeEventEmitter;
+        once(event: 'ready', listener: (driver: Driver) => void): events.NodeEventEmitter;

-        on(event: string, listener: (driver: Driver) => void);
-        on(event: 'ready', listener: (driver: Driver) => void);
+        on(event: string, listener: (driver: Driver) => void): events.NodeEventEmitter;
+        on(event: 'ready', listener: (driver: Driver) => void): events.NodeEventEmitter;
    }

    interface DriverEvents extends events.NodeEventEmitter {
-        once(event: string, listener: (text: string) => void);
-        once(event: 'console.log', listener: (text: string) => void);
-        once(event: 'console.warn', listener: (text: string) => void);
-        once(event: 'console.error', listener: (text: string) => void);
-        once(event: 'window.onerror', listener: (text: string) => void);
+        once(event: string, listener: (text: string) => void): events.NodeEventEmitter;
+        once(event: 'console.log', listener: (text: string) => void): events.NodeEventEmitter;
+        once(event: 'console.warn', listener: (text: string) => void): events.NodeEventEmitter;
+        once(event: 'console.error', listener: (text: string) => void): events.NodeEventEmitter;
+        once(event: 'window.onerror', listener: (text: string) => void): events.NodeEventEmitter;

-        on(event: string, listener: (text: string) => void);
-        on(event: 'console.log', listener: (text: string) => void);
-        on(event: 'console.warn', listener: (text: string) => void);
-        on(event: 'console.error', listener: (text: string) => void);
-        on(event: 'window.onerror', listener: (text: string) => void);
+        on(event: string, listener: (text: string) => void): events.NodeEventEmitter;
+        on(event: 'console.log', listener: (text: string) => void): events.NodeEventEmitter;
+        on(event: 'console.warn', listener: (text: string) => void): events.NodeEventEmitter;
+        on(event: 'console.error', listener: (text: string) => void): events.NodeEventEmitter;
+        on(event: 'window.onerror', listener: (text: string) => void): events.NodeEventEmitter;
    }

    export interface Driver {
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -688,6 +688,12 @@ function _throw() {
    }, "blah: expected [Function] to throw error including 'hello' but got 'testing'");
 }

+function use(){
+    chai.use(function (_chai, utils) {
+      _chai.can.use.any();
+    });
+}
+
 function respondTo() {
    function Foo() {};
    var bar = {};
@@ -0,0 +1 @@
+""
@@ -8,6 +8,9 @@ declare module chai {

    function expect(target: any): Expect;

+    // Provides a way to extend the internals of Chai
+    function use(fn: (chai: any, utils: any) => void);
+
    interface ExpectStatic {
        (target: any): Expect;
    }
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -0,0 +1 @@
+""
@@ -830,44 +830,11 @@ declare module chrome.events {
 // Extension
 ////////////////////
 declare module chrome.extension {
-    interface MessageSender {
-        id: string;
-        tab?: chrome.tabs.Tab;
-    }
-
-    interface Port {
-        postMessage: Function;
-        sender?: MessageSender;
-        onDisconnect: chrome.events.Event;
-        onMessage: chrome.events.Event;
-        name: string;
-    }
-
    interface FetchProperties {
        windowId?: number;
        type?: string;
    }

-    interface ConnectInfo {
-        name?: string;
-    }
-
-    interface ExtensionMessageEvent extends chrome.events.Event {
-        addListener(callback: (message: any, sender: MessageSender, sendResponse: Function) => void): void;
-    }
-
-    interface ExtensionMessageExternalEvent extends chrome.events.Event {
-        addListener(callback: (message: any, sender: MessageSender, sendResponse: Function) => void): void;
-    }
-
-    interface ExtensionConnectEvent extends chrome.events.Event {
-        addListener(callback: (port: Port) => void): void;
-    }
-
-    interface ExtensionConnectExternalEvent extends chrome.events.Event {
-        addListener(callback: (port: Port) => void): void;
-    }
-
    var inIncognitoContext: boolean;
    var lastError: Object;

@@ -876,15 +843,7 @@ declare module chrome.extension {
    export function setUpdateUrlData(data: string): void;
    export function getViews(fetchProperties?: FetchProperties): Window[];
    export function isAllowedFileSchemeAccess(callback: (isAllowedAccess: boolean) => void): void;
-    export function sendMessage(message: any, responseCallback?: (response: any) => void): void;
-    export function sendMessage(extensionId: string, message: any, responseCallback?: (response: any) => void): void;
-    export function connect(extensionId?: string, connectInfo?: ConnectInfo): Port;
    export function isAllowedIncognitoAccess(callback: (isAllowedAccess) => void): void;
-
-    var onMessage: ExtensionMessageEvent;
-    var onMessageExternal: ExtensionMessageExternalEvent;
-    var onConnect: ExtensionConnectEvent;
-    var onConnectExternal: ExtensionConnectExternalEvent;
 }

 ////////////////////
@@ -1461,11 +1420,62 @@ declare module chrome.runtime {
    var lastError: Object;
    var id: string;

+    interface ConnectInfo {
+        name?: string;
+    }
+
    interface InstalledDetails {
        reason: string;
        previousVersion?: string;
    }

+    interface MessageOptions {
+        includeTlsChannelId?: boolean;
+    }
+
+    interface MessageSender {
+        id: string;
+        tab?: chrome.tabs.Tab;
+    }
+
+    interface PlatformInfo {
+        os: string;
+        arch: string;
+        nacl_arch: string;
+    }
+    
+    interface Port {
+        postMessage: Function;
+        sender?: MessageSender;
+        onDisconnect: chrome.events.Event;
+        onMessage: chrome.events.Event;
+        name: string;
+    }
+
+    interface UpdateAvailableDetails {
+        version: string;
+    }
+
+    interface UpdateCheckDetails {
+        version: string;
+    }
+
+    interface ExtensionMessageEvent extends chrome.events.Event {
+        addListener(callback: (message: any, sender: MessageSender, sendResponse: Function) => void): void;
+    }
+
+    interface ExtensionMessageExternalEvent extends chrome.events.Event {
+        addListener(callback: (message: any, sender: MessageSender, sendResponse: Function) => void): void;
+    }
+
+    interface ExtensionConnectEvent extends chrome.events.Event {
+        addListener(callback: (port: Port) => void): void;
+    }
+
+    interface ExtensionConnectExternalEvent extends chrome.events.Event {
+        addListener(callback: (port: Port) => void): void;
+    }
+
    interface RuntimeSuspendEvent extends chrome.events.Event {
        addListener(callback: Function): void;
    }
@@ -1484,17 +1494,43 @@ declare module chrome.runtime {
    interface RuntimeMessageEvent extends chrome.events.Event {
        addListener(callback: Function): void;
    }
+
+    interface RuntimeRestartRequiredEvent extends chrome.events.Event {
+        addListener(callback: (reason: string) => void): void;
+    }
+
+    interface RuntimeUpdateAvailableEvent extends chrome.events.Event {
+        addListener(callback: (details: UpdateAvailableDetails) => void): void;
+    }
    
+    export function connect(connectInfo?: ConnectInfo): Port;
+    export function connect(extensionId: string, connectInfo?: ConnectInfo): Port;
+    export function connectNative(application: string): Port;
    export function getBackgroundPage(callback: (backgroundPage?: Window) => void): void;
    export function getManifest(): Object;
+    export function getPackageDirectoryEntry(callback: (directoryEntry: any) => void): void;
+    export function getPlatformInfo(callback: (platformInfo: PlatformInfo) => void): void;
    export function getURL(path: string): string;
-    
+    export function reload(): void;
+    export function requestUpdateCheck(callback: (status: string, details?: UpdateCheckDetails) => void): void;
+    export function restart(): void;
+    export function sendMessage(message: any, responseCallback?: (response: any) => void): void;
+    export function sendMessage(message: any, options: MessageOptions, responseCallback?: (response: any) => void): void;
+    export function sendMessage(extensionId: string, message: any, responseCallback?: (response: any) => void): void;
+    export function sendMessage(extensionId: string, message: any, options: MessageOptions, responseCallback?: (response: any) => void): void;
+    export function sendNativeMessage(application: string, message: any, responseCallback?: (response: any) => void ): void;
+    export function setUninstallUrl(url: string): void;
+
+    var onConnect: ExtensionConnectEvent;
+    var onConnectExternal: ExtensionConnectExternalEvent;
    var onSuspend: RuntimeSuspendEvent;
    var onStartup: RuntimeStartupEvent;
    var onInstalled: RuntimeInstalledEvent;
    var onSuspendCanceled: RuntimeSuspendCanceledEvent;
    var onMessage: RuntimeMessageEvent;
-    var sendMessage:(req:any, cb:(resp:any)=>void)=>void;
+    var onMessageExternal: RuntimeMessageEvent;
+    var onRestartRequired: RuntimeRestartRequiredEvent;
+    var onUpdateAvailable: RuntimeUpdateAvailableEvent;

 }

@@ -1717,6 +1753,7 @@ declare module chrome.tabs {
    }

    interface TabRemoveInfo {
+        windowId: number;
        isWindowClosing: boolean;
    }

@@ -0,0 +1 @@
+""
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`tsc runner.ts --out runner.js --module commonjs`