Merge pull request #1 from DefinitelyTyped/master

fetch latest code

.gitignore

@@ -13,6 +13,7 @@
 *.map
 *.swp
 .DS_Store
+npm-debug.log
 
 _Resharper.DefinitelyTyped
 bin

.travis.yml

@@ -1,6 +1,6 @@
 language: node_js
 node_js:
-  - "iojs-v2"
+  - 4
 
 sudo: false
 

FileSaver/FileSaver-tests.ts

@@ -6,6 +6,7 @@
 function testSaveAs() {
     var data: Blob = new Blob(["Hello, world!"], {type: "text/plain;charset=utf-8"});
     var filename: string = 'hello world.txt';
-    
-    saveAs(data, filename);
+    var disableAutoBOM = true;
+
+    saveAs(data, filename, disableAutoBOM);
 }

FileSaver/FileSaver.d.ts

@@ -20,8 +20,14 @@ interface FileSaver {
          * @summary File name.
          * @type {DOMString}
          */
-        filename: string
+	 filename: string,
+
+	 /**
+	  * @summary Disable Unicode text encoding hints or not.
+	  * @type {boolean}
+	  */
+	 disableAutoBOM?: boolean
     ): void
 }
 
-declare var saveAs: FileSaver;
+declare var saveAs: FileSaver;

OpenJsCad/openjscad-tests.ts

@@ -0,0 +1,266 @@
+/// <reference path="./openjscad.d.ts" />
+
+function test() {
+
+  var gProcessor: OpenJsCad.Processor = null;
+  
+  // Show all exceptions to the user:
+  OpenJsCad.AlertUserOfUncaughtExceptions();
+  
+  function onload()
+  {
+    gProcessor = new OpenJsCad.Processor(<HTMLDivElement>document.getElementById("viewer"));
+    updateSolid();
+  }
+  
+  function updateSolid()
+  {
+    gProcessor.setJsCad((<HTMLTextAreaElement>document.getElementById('code')).value);
+  }
+  
+
+}
+
+function main()
+{
+  // Main entry point; here we construct our solid: 
+  var gear = involuteGear(
+    15,
+    10,
+    20,
+    0,
+    5
+  );
+  var centerhole = CSG.cylinder({start: [0,0,-5], end: [0,0,5], radius: 2, resolution: 16});
+  gear = gear.subtract(centerhole);
+  return gear;
+}
+
+function involuteGear(numTeeth: number, circularPitch: number, pressureAngle: number, clearance: number, thickness: number)
+{
+  // default values:
+  if(arguments.length < 3) pressureAngle = 20;
+  if(arguments.length < 4) clearance = 0;
+  if(arguments.length < 4) thickness = 1;
+  
+  var addendum = circularPitch / Math.PI;
+  var dedendum = addendum + clearance;
+  
+  // radiuses of the 4 circles:
+  var pitchRadius = numTeeth * circularPitch / (2 * Math.PI);
+  var baseRadius = pitchRadius * Math.cos(Math.PI * pressureAngle / 180);
+  var outerRadius = pitchRadius + addendum;
+  var rootRadius = pitchRadius - dedendum;
+
+  var maxtanlength = Math.sqrt(outerRadius*outerRadius - baseRadius*baseRadius);
+  var maxangle = maxtanlength / baseRadius;
+
+  var tl_at_pitchcircle = Math.sqrt(pitchRadius*pitchRadius - baseRadius*baseRadius);
+  var angle_at_pitchcircle = tl_at_pitchcircle / baseRadius;
+  var diffangle = angle_at_pitchcircle - Math.atan(angle_at_pitchcircle);
+  var angularToothWidthAtBase = Math.PI / numTeeth + 2*diffangle;
+
+  // build a single 2d tooth in the 'points' array:
+  var resolution = 5;
+  var points = [new CSG.Vector2D(0,0)];
+  for(var i = 0; i <= resolution; i++)
+  {
+    // first side of the tooth:
+    var angle = maxangle * i / resolution;
+    var tanlength = angle * baseRadius;
+    var radvector = CSG.Vector2D.fromAngle(angle);    
+    var tanvector = radvector.normal();
+    var p = radvector.times(baseRadius).plus(tanvector.times(tanlength));
+    points[i+1] = p;
+    
+    // opposite side of the tooth:
+    radvector = CSG.Vector2D.fromAngle(angularToothWidthAtBase - angle);    
+    tanvector = radvector.normal().negated();
+    p = radvector.times(baseRadius).plus(tanvector.times(tanlength));
+    points[2 * resolution + 2 - i] = p;
+  }
+
+  // create the polygon and extrude into 3D:
+  var tooth3d = new CSG.Polygon2D(points).extrude({offset: [0, 0, thickness]});
+
+  var allteeth = new CSG();
+  for(var i = 0; i < numTeeth; i++)
+  {
+    var angle = i*360/numTeeth;
+    var rotatedtooth = <CSG>tooth3d.rotateZ(angle);
+    allteeth = allteeth.unionForNonIntersecting(rotatedtooth);
+  }
+
+  // build the root circle:  
+  points = [];
+  var toothAngle = 2 * Math.PI / numTeeth;
+  var toothCenterAngle = 0.5 * angularToothWidthAtBase; 
+  for(var i = 0; i < numTeeth; i++)
+  {
+    var angle = toothCenterAngle + i * toothAngle;
+    var p = CSG.Vector2D.fromAngle(angle).times(rootRadius);
+    points.push(p);
+  }
+
+  // create the polygon and extrude into 3D:
+  var rootcircle = new CSG.Polygon2D(points).extrude({offset: [0, 0, thickness]});
+
+  var result = rootcircle.union(allteeth);
+
+  // center at origin:
+  result = <CSG>result.translate([0, 0, -thickness/2]);
+
+  return result;
+}
+
+var cylresolution=16;
+
+
+function main2()
+{
+  var params = 
+    {
+      quality: 0,
+      diameter1: 12.2,
+      shaftlength1: 15,
+      outerlength1: 20,
+      nutradius1: 4.65,
+      nutthickness1: 4.2,
+      screwdiameter1: 5,
+      diameter2: 9.5,
+      shaftlength2: 10,
+      outerlength2: 15,
+      nutradius2: 3.2,
+      nutthickness2: 2.6,
+      screwdiameter2: 3,
+      outerdiameter: 30,
+      spiderlength: 12,
+      spidermargin: 0,
+      numteeth: 2
+    };
+
+
+  cylresolution=(params.quality == 1)? 64:16;
+
+  var outerdiameter=params.outerdiameter;
+  outerdiameter=Math.max(outerdiameter, params.diameter1+0.5);
+  outerdiameter=Math.max(outerdiameter, params.diameter2+0.5);
+
+  var spidercenterdiameter=outerdiameter/2;
+
+  var part1=makeShaft(params.diameter1, outerdiameter,spidercenterdiameter,params.shaftlength1,params.outerlength1,params.spiderlength, params.nutradius1, params.nutthickness1, params.screwdiameter1, params.numteeth);
+  var part2=makeShaft(params.diameter2, outerdiameter,spidercenterdiameter,params.shaftlength2,params.outerlength2,params.spiderlength, params.nutradius2, params.nutthickness2, params.screwdiameter2, params.numteeth);
+  var spider=makeSpider(outerdiameter, spidercenterdiameter, params.spiderlength, params.numteeth);
+
+  if(params.spidermargin > 0)
+  {
+    spider=spider.contract(params.spidermargin, 4);
+  }
+
+  // rotate shaft parts for better 3d printing:
+  part1=<CSG>part1.rotateX(180).translate([0,0,params.outerlength1+params.spiderlength]);
+  part2=<CSG>part2.rotateX(180).translate([0,0,params.outerlength2+params.spiderlength]);
+
+  var result=<CSG>part1.translate([-outerdiameter-5,0,0]);
+  result=result.union(<CSG>part2.translate([0,0,0]));
+  result=result.union(<CSG>spider.translate([outerdiameter+5,0,-params.spidermargin]));
+  return result;
+}
+
+function makeShaft(innerdiameter: number, outerdiameter: number, spidercenterdiameter: number, shaftlength: number, outerlength: number, spiderlength: number, nutradius: number, nutthickness: number, screwdiameter: number, numteeth: number)
+{
+  var result=CSG.cylinder({start:[0,0,0], end:[0,0,outerlength], radius:outerdiameter/2, resolution:cylresolution});
+
+  for(var i=0; i < numteeth; i++)
+  {
+    var angle=i*360/numteeth;
+    var pie=makePie(outerdiameter/2, spiderlength,angle-45/numteeth, angle+45/numteeth);
+    pie=<CSG>pie.translate([0,0,outerlength]);
+    result=result.union(pie);
+  }
+  var spidercylinder=CSG.cylinder({start:[0,0,outerlength], end:[0,0,outerlength+spiderlength],radius:spidercenterdiameter/2,resolution:cylresolution});
+  result=result.subtract(spidercylinder);
+  var shaftcylinder=CSG.cylinder({start:[0,0,0], end:[0,0,shaftlength], radius:innerdiameter/2, resolution:cylresolution});
+  result=result.subtract(shaftcylinder);
+
+  var screwz=shaftlength/2;
+  if(screwz < nutradius) screwz=nutradius;
+  var nutcutout = <CSG>hexagon(nutradius, nutthickness).translate([0,0,-nutthickness/2]);
+  var grubnutradiusAtFlatSide = nutradius * Math.cos(Math.PI / 180 * 30);
+  var nutcutoutrectangle = CSG.cube({
+    radius: [outerlength/2, grubnutradiusAtFlatSide, nutthickness/2],
+    center: [outerlength/2, 0, 0],
+  });
+  nutcutout = nutcutout.union(nutcutoutrectangle);
+  nutcutout = <CSG>nutcutout.rotateY(90);
+  nutcutout = <CSG>nutcutout.translate([(outerdiameter+innerdiameter)/4, 0, screwz]);
+  result = result.subtract(nutcutout);
+
+  var screwcutout=CSG.cylinder({
+    start: [outerdiameter/2, 0, screwz],
+    end: [0, 0, screwz],
+    radius: screwdiameter/2,
+    resolution:cylresolution
+  });
+  result=result.subtract(screwcutout);
+
+//return nutcutout;
+//  nutcutout = nutcutout.translate([-grubnutheight/2 - centerholeradius - nutdistance,0,0]);
+
+  return result;
+}
+
+function makePie(radius: number, height: number, startangle: number, endangle: number)
+{
+  var absangle=Math.abs(startangle-endangle);
+  if(absangle >= 180)
+  {
+    throw new Error("Pie angle must be less than 180 degrees");
+  }
+  var numsteps=cylresolution*absangle/360;
+  if(numsteps < 1) numsteps=1;
+  var points: CSG.Vector2D[] = [];
+  for(var i=0; i <= numsteps; i++)
+  {
+    var angle=startangle+i/numsteps*(endangle-startangle);
+    var vec = CSG.Vector2D.fromAngleDegrees(angle).times(radius);
+    points.push(vec);
+  }
+  points.push(new CSG.Vector2D(0,0));
+  var shape2d=new CSG.Polygon2D(points);
+  var extruded=shape2d.extrude({
+    offset: [0,0,height],   // direction for extrusion
+  });
+  return extruded;
+}
+
+function hexagon(radius: number, height: number)
+{
+  var vertices: CSG.Vertex[] = [];
+  for(var i=0; i < 6; i++)
+  {
+    var point=CSG.Vector2D.fromAngleDegrees(-i*60).times(radius).toVector3D(0);
+    vertices.push(new CSG.Vertex(point));
+  }
+  var polygon=new CSG.Polygon(vertices);
+  var hexagon=polygon.extrude([0,0,height]);
+  return hexagon;
+}
+
+function makeSpider(outerdiameter: number, spidercenterdiameter: number, spiderlength: number, numteeth: number)
+{
+  var result=new CSG();
+  var numspiderteeth=numteeth*2; // spider has twice the number of teeth
+  for(var i=0; i < numspiderteeth; i++)
+  {
+    var angle=i*360/numspiderteeth;
+    var pie=makePie(outerdiameter/2, spiderlength,angle-90/numspiderteeth, angle+90/numspiderteeth);
+    pie=<CSG>pie.translate([0,0,0]);
+    result=result.union(pie);
+  }
+
+  var centercylinder=CSG.cylinder({start:[0,0,0], end:[0,0,spiderlength], radius:spidercenterdiameter/2, resolution:cylresolution});
+  result=result.union(centercylinder);
+
+  return result;
+}

OpenJsCad/openjscad.d.ts

@@ -0,0 +1,912 @@
+// Type definitions for OpenJsCad.js
+// Project: https://github.com/joostn/OpenJsCad
+// Definitions by: Dan Marshall <https://github.com/danmarshall>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+/// <reference path="../threejs/three.d.ts" />
+
+declare module THREE {
+    var CSG: {
+        fromCSG: (csg: CSG, defaultColor: any) => {
+            colorMesh: Mesh;
+            wireframe: Mesh;
+            boundLen: number;
+        };
+        getGeometryVertex: (geometry: any, vertex_position: any) => number;
+    };
+    function OrbitControls(object: any, domElement: any): void;
+    function SpriteCanvasMaterial(parameters?: any): void;
+    interface ICanvasRendererOptions {
+        canvas?: HTMLCanvasElement;
+        alpha?: boolean;
+    }
+    class CanvasRenderer implements Renderer {
+        domElement: HTMLCanvasElement;
+        private pixelRatio;
+        private autoClear;
+        private sortObjects;
+        private sortElements;
+        private info;
+        private _projector;
+        private _renderData;
+        private _elements;
+        private _lights;
+        private _canvas;
+        private _canvasWidth;
+        private _canvasHeight;
+        private _canvasWidthHalf;
+        private _canvasHeightHalf;
+        private _viewportX;
+        private _viewportY;
+        private _viewportWidth;
+        private _viewportHeight;
+        private _context;
+        private _clearColor;
+        private _clearAlpha;
+        private _contextGlobalAlpha;
+        private _contextGlobalCompositeOperation;
+        private _contextStrokeStyle;
+        private _camera;
+        private _contextFillStyle;
+        private _contextLineWidth;
+        private _contextLineCap;
+        private _contextLineJoin;
+        private _contextLineDash;
+        private _v1;
+        private _v2;
+        private _v3;
+        private _v4;
+        private _v5;
+        private _v6;
+        private _v1x;
+        private _v1y;
+        private _v2x;
+        private _v2y;
+        private _v3x;
+        private _v3y;
+        private _v4x;
+        private _v4y;
+        private _v5x;
+        private _v5y;
+        private _v6x;
+        private _v6y;
+        private _color;
+        private _color1;
+        private _color2;
+        private _color3;
+        private _color4;
+        private _diffuseColor;
+        private _emissiveColor;
+        private _lightColor;
+        private _patterns;
+        private _image;
+        private _uvs;
+        private _uv1x;
+        private _uv1y;
+        private _uv2x;
+        private _uv2y;
+        private _uv3x;
+        private _uv3y;
+        private _clipBox;
+        private _clearBox;
+        private _elemBox;
+        private _ambientLight;
+        private _directionalLights;
+        private _pointLights;
+        private _vector3;
+        private _centroid;
+        private _normal;
+        private _normalViewMatrix;
+        constructor(parameters: ICanvasRendererOptions);
+        supportsVertexTextures(): void;
+        setFaceCulling: () => void;
+        getPixelRatio(): number;
+        setPixelRatio(value: any): void;
+        setSize(width: any, height: any, updateStyle: any): void;
+        setViewport(x: any, y: any, width: any, height: any): void;
+        setScissor(): void;
+        enableScissorTest(): void;
+        setClearColor(color: any, alpha: any): void;
+        setClearColorHex(hex: any, alpha: any): void;
+        getClearColor(): Color;
+        getClearAlpha(): number;
+        getMaxAnisotropy(): number;
+        clear(): void;
+        clearColor(): void;
+        clearDepth(): void;
+        clearStencil(): void;
+        render(scene: Scene, camera: Camera, renderTarget?: RenderTarget, forceClear?: boolean): void;
+        calculateLights(): void;
+        calculateLight(position: any, normal: any, color: any): void;
+        renderSprite(v1: any, element: any, material: any): void;
+        renderLine(v1: any, v2: any, element: any, material: any): void;
+        renderFace3(v1: any, v2: any, v3: any, uv1: any, uv2: any, uv3: any, element: any, material: any): void;
+        drawTriangle(x0: any, y0: any, x1: any, y1: any, x2: any, y2: any): void;
+        strokePath(color: any, linewidth: any, linecap: any, linejoin: any): void;
+        fillPath(color: any): void;
+        onTextureUpdate(event: any): void;
+        textureToPattern(texture: any): void;
+        patternPath(x0: any, y0: any, x1: any, y1: any, x2: any, y2: any, u0: any, v0: any, u1: any, v1: any, u2: any, v2: any, texture: any): void;
+        clipImage(x0: any, y0: any, x1: any, y1: any, x2: any, y2: any, u0: any, v0: any, u1: any, v1: any, u2: any, v2: any, image: any): void;
+        expand(v1: any, v2: any, pixels: any): void;
+        setOpacity(value: any): void;
+        setBlending(value: any): void;
+        setLineWidth(value: any): void;
+        setLineCap(value: any): void;
+        setLineJoin(value: any): void;
+        setStrokeStyle(value: any): void;
+        setFillStyle(value: any): void;
+        setLineDash(value: any): void;
+    }
+    function RenderableObject(): void;
+    function RenderableFace(): void;
+    function RenderableVertex(): void;
+    function RenderableLine(): void;
+    function RenderableSprite(): void;
+    function Projector(): void;
+}
+declare module OpenJsCad {
+    interface ILog {
+        (x: string): void;
+        prevLogTime?: number;
+    }
+    var log: ILog;
+    interface IViewerOptions {
+        drawLines?: boolean;
+        drawFaces?: boolean;
+        color?: number[];
+        bgColor?: number;
+        noWebGL?: boolean;
+    }
+    interface ProcessorOptions extends IViewerOptions {
+        verbose?: boolean;
+        viewerwidth?: number;
+        viewerheight?: number;
+        viewerheightratio?: number;
+    }
+    class Viewer {
+        private perspective;
+        private drawOptions;
+        private size;
+        private defaultColor_;
+        private bgColor_;
+        private containerElm_;
+        private scene_;
+        private camera_;
+        private controls_;
+        private renderer_;
+        private canvas;
+        private pauseRender_;
+        private requestID_;
+        constructor(containerElm: any, size: any, options: IViewerOptions);
+        createScene(drawAxes: any, axLen: any): void;
+        createCamera(): void;
+        createControls(canvas: any): void;
+        webGLAvailable(): boolean;
+        createRenderer(bool_noWebGL: any): void;
+        render(): void;
+        animate(): void;
+        cancelAnimate(): void;
+        refreshRenderer(bool_noWebGL: any): void;
+        drawAxes(axLen: any): void;
+        setCsg(csg: any, resetZoom: any): void;
+        applyDrawOptions(): void;
+        clear(): void;
+        getUserMeshes(str?: any): THREE.Object3D[];
+        resetZoom(r: any): void;
+        parseSizeParams(): void;
+        handleResize(): void;
+    }
+    function makeAbsoluteUrl(url: any, baseurl: any): any;
+    function isChrome(): boolean;
+    function runMainInWorker(mainParameters: any): void;
+    function expandResultObjectArray(result: any): any;
+    function checkResult(result: any): void;
+    function resultToCompactBinary(resultin: any): any;
+    function resultFromCompactBinary(resultin: any): any;
+    function parseJsCadScriptSync(script: any, mainParameters: any, debugging: any): any;
+    function parseJsCadScriptASync(script: any, mainParameters: any, options: any, callback: any): Worker;
+    function getWindowURL(): URL;
+    function textToBlobUrl(txt: any): string;
+    function revokeBlobUrl(url: any): void;
+    function FileSystemApiErrorHandler(fileError: any, operation: any): void;
+    function AlertUserOfUncaughtExceptions(): void;
+    function getParamDefinitions(script: any): any[];
+    interface EventHandler {
+        (ev?: Event): any;
+    }
+    /**
+     * options parameter:
+     * - drawLines: display wireframe lines
+     * - drawFaces: display surfaces
+     * - bgColor: canvas background color
+     * - color: object color
+     * - viewerwidth, viewerheight: set rendering size. Works with any css unit.
+     *     viewerheight can also be specified as a ratio to width, ie number e (0, 1]
+     * - noWebGL: force render without webGL
+     * - verbose: show additional info (currently only time used for rendering)
+     */
+    interface ViewerSize {
+        widthDefault: string;
+        heightDefault: string;
+        width: number;
+        height: number;
+        heightratio: number;
+    }
+    class Processor {
+        private containerdiv;
+        private options;
+        private onchange;
+        private static widthDefault;
+        private static heightDefault;
+        private viewerdiv;
+        private viewer;
+        private viewerSize;
+        private processing;
+        private currentObject;
+        private hasValidCurrentObject;
+        private hasOutputFile;
+        private worker;
+        private paramDefinitions;
+        private paramControls;
+        private script;
+        private hasError;
+        private debugging;
+        private errordiv;
+        private errorpre;
+        private statusdiv;
+        private controldiv;
+        private statusspan;
+        private statusbuttons;
+        private abortbutton;
+        private renderedElementDropdown;
+        private formatDropdown;
+        private generateOutputFileButton;
+        private downloadOutputFileLink;
+        private parametersdiv;
+        private parameterstable;
+        private currentFormat;
+        private filename;
+        private currentObjects;
+        private currentObjectIndex;
+        private isFirstRender_;
+        private outputFileDirEntry;
+        private outputFileBlobUrl;
+        constructor(containerdiv: HTMLDivElement, options?: ProcessorOptions, onchange?: EventHandler);
+        static convertToSolid(obj: any): any;
+        cleanOption(option: any, deflt: any): any;
+        toggleDrawOption(str: any): boolean;
+        setDrawOption(str: any, bool: any): void;
+        handleResize(): void;
+        createElements(): void;
+        getFilenameForRenderedObject(): string;
+        setRenderedObjects(obj: any): void;
+        setSelectedObjectIndex(index: number): void;
+        selectedFormat(): any;
+        selectedFormatInfo(): any;
+        updateDownloadLink(): void;
+        clearViewer(): void;
+        abort(): void;
+        enableItems(): void;
+        setOpenJsCadPath(path: string): void;
+        addLibrary(lib: any): void;
+        setError(txt: string): void;
+        setDebugging(debugging: boolean): void;
+        setJsCad(script: string, filename?: string): void;
+        getParamValues(): {};
+        rebuildSolid(): void;
+        hasSolid(): boolean;
+        isProcessing(): boolean;
+        clearOutputFile(): void;
+        generateOutputFile(): void;
+        currentObjectToBlob(): any;
+        supportedFormatsForCurrentObject(): string[];
+        formatInfo(format: any): any;
+        downloadLinkTextForCurrentObject(): string;
+        generateOutputFileBlobUrl(): void;
+        generateOutputFileFileSystem(): void;
+        createParamControls(): void;
+    }
+}
+interface Window {
+    Worker: Worker;
+//    URL: URL;
+    webkitURL: URL;
+    requestFileSystem: any;
+    webkitRequestFileSystem: any;
+}
+interface IAMFStringOptions {
+    unit: string;
+}
+declare class CxG {
+    toStlString(): string;
+    toStlBinary(): void;
+    toAMFString(AMFStringOptions?: IAMFStringOptions): void;
+    getBounds(): CxG[];
+    transform(matrix4x4: CSG.Matrix4x4): CxG;
+    mirrored(plane: CSG.Plane): CxG;
+    mirroredX(): CxG;
+    mirroredY(): CxG;
+    mirroredZ(): CxG;
+    translate(v: number[]): CxG;
+    translate(v: CSG.Vector3D): CxG;
+    scale(f: CSG.Vector3D): CxG;
+    rotateX(deg: number): CxG;
+    rotateY(deg: number): CxG;
+    rotateZ(deg: number): CxG;
+    rotate(rotationCenter: CSG.Vector3D, rotationAxis: CSG.Vector3D, degrees: number): CxG;
+    rotateEulerAngles(alpha: number, beta: number, gamma: number, position: number[]): CxG;
+}
+interface ICenter {
+    center(cAxes: string[]): CxG;
+}
+declare class CSG extends CxG implements ICenter {
+    polygons: CSG.Polygon[];
+    properties: CSG.Properties;
+    isCanonicalized: boolean;
+    isRetesselated: boolean;
+    cachedBoundingBox: CSG.Vector3D[];
+    static defaultResolution2D: number;
+    static defaultResolution3D: number;
+    static fromPolygons(polygons: CSG.Polygon[]): CSG;
+    static fromSlices(options: any): CSG;
+    static fromObject(obj: any): CSG;
+    static fromCompactBinary(bin: any): CSG;
+    toPolygons(): CSG.Polygon[];
+    union(csg: CSG[]): CSG;
+    union(csg: CSG): CSG;
+    unionSub(csg: CSG, retesselate?: boolean, canonicalize?: boolean): CSG;
+    unionForNonIntersecting(csg: CSG): CSG;
+    subtract(csg: CSG[]): CSG;
+    subtract(csg: CSG): CSG;
+    subtractSub(csg: CSG, retesselate: boolean, canonicalize: boolean): CSG;
+    intersect(csg: CSG[]): CSG;
+    intersect(csg: CSG): CSG;
+    intersectSub(csg: CSG, retesselate?: boolean, canonicalize?: boolean): CSG;
+    invert(): CSG;
+    transform1(matrix4x4: CSG.Matrix4x4): CSG;
+    transform(matrix4x4: CSG.Matrix4x4): CSG;
+    toString(): string;
+    expand(radius: number, resolution: number): CSG;
+    contract(radius: number, resolution: number): CSG;
+    stretchAtPlane(normal: number[], point: number[], length: number): CSG;
+    expandedShell(radius: number, resolution: number, unionWithThis: boolean): CSG;
+    canonicalized(): CSG;
+    reTesselated(): CSG;
+    getBounds(): CSG.Vector3D[];
+    mayOverlap(csg: CSG): boolean;
+    cutByPlane(plane: CSG.Plane): CSG;
+    connectTo(myConnector: CSG.Connector, otherConnector: CSG.Connector, mirror: boolean, normalrotation: number): CSG;
+    setShared(shared: CSG.Polygon.Shared): CSG;
+    setColor(args: any): CSG;
+    toCompactBinary(): {
+        "class": string;
+        numPolygons: number;
+        numVerticesPerPolygon: Uint32Array;
+        polygonPlaneIndexes: Uint32Array;
+        polygonSharedIndexes: Uint32Array;
+        polygonVertices: Uint32Array;
+        vertexData: Float64Array;
+        planeData: Float64Array;
+        shared: CSG.Polygon.Shared[];
+    };
+    toPointCloud(cuberadius: any): CSG;
+    getTransformationAndInverseTransformationToFlatLying(): any;
+    getTransformationToFlatLying(): any;
+    lieFlat(): CSG;
+    projectToOrthoNormalBasis(orthobasis: CSG.OrthoNormalBasis): CAG;
+    sectionCut(orthobasis: CSG.OrthoNormalBasis): CAG;
+    fixTJunctions(): CSG;
+    toTriangles(): any[];
+    getFeatures(features: any): any;
+    center(cAxes: string[]): CxG;
+    toX3D(): Blob;
+    toStlBinary(): Blob;
+    toStlString(): string;
+    toAMFString(m: IAMFStringOptions): Blob;
+}
+declare module CSG {
+    function fnNumberSort(a: any, b: any): number;
+    function parseOption(options: any, optionname: any, defaultvalue: any): any;
+    function parseOptionAs3DVector(options: any, optionname: any, defaultvalue: any): Vector3D;
+    function parseOptionAs3DVectorList(options: any, optionname: any, defaultvalue: any): any;
+    function parseOptionAs2DVector(options: any, optionname: any, defaultvalue: any): any;
+    function parseOptionAsFloat(options: any, optionname: any, defaultvalue: any): any;
+    function parseOptionAsInt(options: any, optionname: any, defaultvalue: any): any;
+    function parseOptionAsBool(options: any, optionname: any, defaultvalue: any): any;
+    function cube(options: any): CSG;
+    function sphere(options: any): CSG;
+    function cylinder(options: any): CSG;
+    function roundedCylinder(options: any): CSG;
+    function roundedCube(options: any): CSG;
+    /**
+     * polyhedron accepts openscad style arguments. I.e. define face vertices clockwise looking from outside
+     */
+    function polyhedron(options: any): CSG;
+    function IsFloat(n: any): boolean;
+    function solve2Linear(a: any, b: any, c: any, d: any, u: any, v: any): number[];
+    class Vector3D extends CxG {
+        x: number;
+        y: number;
+        z: number;
+        constructor(v3: Vector3D);
+        constructor(v2: Vector2D);
+        constructor(v2: number[]);
+        constructor(x: number, y: number);
+        constructor(x: number, y: number, z: number);
+        static Create(x: number, y: number, z: number): Vector3D;
+        clone(): Vector3D;
+        negated(): Vector3D;
+        abs(): Vector3D;
+        plus(a: Vector3D): Vector3D;
+        minus(a: Vector3D): Vector3D;
+        times(a: number): Vector3D;
+        dividedBy(a: number): Vector3D;
+        dot(a: Vector3D): number;
+        lerp(a: Vector3D, t: number): Vector3D;
+        lengthSquared(): number;
+        length(): number;
+        unit(): Vector3D;
+        cross(a: Vector3D): Vector3D;
+        distanceTo(a: Vector3D): number;
+        distanceToSquared(a: Vector3D): number;
+        equals(a: Vector3D): boolean;
+        multiply4x4(matrix4x4: Matrix4x4): Vector3D;
+        transform(matrix4x4: Matrix4x4): Vector3D;
+        toString(): string;
+        randomNonParallelVector(): Vector3D;
+        min(p: Vector3D): Vector3D;
+        max(p: Vector3D): Vector3D;
+        toStlString(): string;
+        toAMFString(): string;
+    }
+    class Vertex extends CxG {
+        pos: Vector3D;
+        tag: number;
+        constructor(pos: Vector3D);
+        static fromObject(obj: any): Vertex;
+        flipped(): Vertex;
+        getTag(): number;
+        interpolate(other: Vertex, t: number): Vertex;
+        transform(matrix4x4: Matrix4x4): Vertex;
+        toString(): string;
+        toStlString(): string;
+        toAMFString(): string;
+    }
+    class Plane extends CxG {
+        normal: Vector3D;
+        w: number;
+        tag: number;
+        constructor(normal: Vector3D, w: number);
+        static fromObject(obj: any): Plane;
+        static EPSILON: number;
+        static fromVector3Ds(a: Vector3D, b: Vector3D, c: Vector3D): Plane;
+        static anyPlaneFromVector3Ds(a: Vector3D, b: Vector3D, c: Vector3D): Plane;
+        static fromPoints(a: Vector3D, b: Vector3D, c: Vector3D): Plane;
+        static fromNormalAndPoint(normal: Vector3D, point: Vector3D): Plane;
+        static fromNormalAndPoint(normal: number[], point: number[]): Plane;
+        flipped(): Plane;
+        getTag(): number;
+        equals(n: Plane): boolean;
+        transform(matrix4x4: Matrix4x4): Plane;
+        splitPolygon(polygon: Polygon): {
+            type: any;
+            front: any;
+            back: any;
+        };
+        splitLineBetweenPoints(p1: Vector3D, p2: Vector3D): Vector3D;
+        intersectWithLine(line3d: Line3D): Vector3D;
+        intersectWithPlane(plane: Plane): Line3D;
+        signedDistanceToPoint(point: Vector3D): number;
+        toString(): string;
+        mirrorPoint(point3d: Vector3D): Vector3D;
+    }
+    class Polygon extends CxG {
+        vertices: Vertex[];
+        shared: Polygon.Shared;
+        plane: Plane;
+        cachedBoundingSphere: any;
+        cachedBoundingBox: Vector3D[];
+        static defaultShared: CSG.Polygon.Shared;
+        constructor(vertices: Vector3D, shared?: Polygon.Shared, plane?: Plane);
+        constructor(vertices: Vertex[], shared?: Polygon.Shared, plane?: Plane);
+        static fromObject(obj: any): Polygon;
+        checkIfConvex(): void;
+        setColor(args: any): Polygon;
+        getSignedVolume(): number;
+        getArea(): number;
+        getTetraFeatures(features: any): any[];
+        extrude(offsetvector: any): CSG;
+        boundingSphere(): any;
+        boundingBox(): Vector3D[];
+        flipped(): Polygon;
+        transform(matrix4x4: Matrix4x4): Polygon;
+        toString(): string;
+        projectToOrthoNormalBasis(orthobasis: OrthoNormalBasis): CAG;
+        /**
+            * Creates solid from slices (CSG.Polygon) by generating walls
+            * @param {Object} options Solid generating options
+            *  - numslices {Number} Number of slices to be generated
+            *  - callback(t, slice) {Function} Callback function generating slices.
+            *          arguments: t = [0..1], slice = [0..numslices - 1]
+            *          return: CSG.Polygon or null to skip
+            *  - loop {Boolean} no flats, only walls, it's used to generate solids like a tor
+            */
+        solidFromSlices(options: any): CSG;
+        /**
+            *
+            * @param walls Array of wall polygons
+            * @param bottom Bottom polygon
+            * @param top Top polygon
+            */
+        private _addWalls(walls, bottom, top, bFlipped);
+        static verticesConvex(vertices: Vertex[], planenormal: any): boolean;
+        static createFromPoints(points: number[][], shared?: CSG.Polygon.Shared, plane?: Plane): Polygon;
+        static isConvexPoint(prevpoint: any, point: any, nextpoint: any, normal: any): boolean;
+        static isStrictlyConvexPoint(prevpoint: any, point: any, nextpoint: any, normal: any): boolean;
+        toStlString(): string;
+    }
+}
+declare module CSG.Polygon {
+    class Shared {
+        color: any;
+        tag: any;
+        constructor(color: any);
+        static fromObject(obj: any): Shared;
+        static fromColor(args: any): Shared;
+        getTag(): any;
+        getHash(): any;
+    }
+}
+declare module CSG {
+    class PolygonTreeNode {
+        parent: any;
+        children: any;
+        polygon: Polygon;
+        removed: boolean;
+        constructor();
+        addPolygons(polygons: any): void;
+        remove(): void;
+        isRemoved(): boolean;
+        isRootNode(): boolean;
+        invert(): void;
+        getPolygon(): Polygon;
+        getPolygons(result: Polygon[]): void;
+        splitByPlane(plane: any, coplanarfrontnodes: any, coplanarbacknodes: any, frontnodes: any, backnodes: any): void;
+        _splitByPlane(plane: any, coplanarfrontnodes: any, coplanarbacknodes: any, frontnodes: any, backnodes: any): void;
+        addChild(polygon: Polygon): PolygonTreeNode;
+        invertSub(): void;
+        recursivelyInvalidatePolygon(): void;
+    }
+    class Tree {
+        polygonTree: PolygonTreeNode;
+        rootnode: Node;
+        constructor(polygons: Polygon[]);
+        invert(): void;
+        clipTo(tree: Tree, alsoRemovecoplanarFront?: boolean): void;
+        allPolygons(): Polygon[];
+        addPolygons(polygons: Polygon[]): void;
+    }
+    class Node {
+        parent: Node;
+        plane: Plane;
+        front: any;
+        back: any;
+        polygontreenodes: PolygonTreeNode[];
+        constructor(parent: Node);
+        invert(): void;
+        clipPolygons(polygontreenodes: PolygonTreeNode[], alsoRemovecoplanarFront: boolean): void;
+        clipTo(tree: Tree, alsoRemovecoplanarFront: boolean): void;
+        addPolygonTreeNodes(polygontreenodes: PolygonTreeNode[]): void;
+        getParentPlaneNormals(normals: Vector3D[], maxdepth: number): void;
+    }
+    class Matrix4x4 {
+        elements: number[];
+        constructor(elements?: number[]);
+        plus(m: Matrix4x4): Matrix4x4;
+        minus(m: Matrix4x4): Matrix4x4;
+        multiply(m: Matrix4x4): Matrix4x4;
+        clone(): Matrix4x4;
+        rightMultiply1x3Vector(v: Vector3D): Vector3D;
+        leftMultiply1x3Vector(v: Vector3D): Vector3D;
+        rightMultiply1x2Vector(v: Vector2D): Vector2D;
+        leftMultiply1x2Vector(v: Vector2D): Vector2D;
+        isMirroring(): boolean;
+        static unity(): Matrix4x4;
+        static rotationX(degrees: number): Matrix4x4;
+        static rotationY(degrees: number): Matrix4x4;
+        static rotationZ(degrees: number): Matrix4x4;
+        static rotation(rotationCenter: CSG.Vector3D, rotationAxis: CSG.Vector3D, degrees: number): Matrix4x4;
+        static translation(v: number[]): Matrix4x4;
+        static translation(v: Vector3D): Matrix4x4;
+        static mirroring(plane: Plane): Matrix4x4;
+        static scaling(v: number[]): Matrix4x4;
+        static scaling(v: Vector3D): Matrix4x4;
+    }
+    class Vector2D extends CxG {
+        x: number;
+        y: number;
+        constructor(x: number, y: number);
+        constructor(x: number[]);
+        constructor(x: Vector2D);
+        static fromAngle(radians: number): Vector2D;
+        static fromAngleDegrees(degrees: number): Vector2D;
+        static fromAngleRadians(radians: number): Vector2D;
+        static Create(x: number, y: number): Vector2D;
+        toVector3D(z: number): Vector3D;
+        equals(a: Vector2D): boolean;
+        clone(): Vector2D;
+        negated(): Vector2D;
+        plus(a: Vector2D): Vector2D;
+        minus(a: Vector2D): Vector2D;
+        times(a: number): Vector2D;
+        dividedBy(a: number): Vector2D;
+        dot(a: Vector2D): number;
+        lerp(a: Vector2D, t: number): Vector2D;
+        length(): number;
+        distanceTo(a: Vector2D): number;
+        distanceToSquared(a: Vector2D): number;
+        lengthSquared(): number;
+        unit(): Vector2D;
+        cross(a: Vector2D): number;
+        normal(): Vector2D;
+        multiply4x4(matrix4x4: Matrix4x4): Vector2D;
+        transform(matrix4x4: Matrix4x4): Vector2D;
+        angle(): number;
+        angleDegrees(): number;
+        angleRadians(): number;
+        min(p: Vector2D): Vector2D;
+        max(p: Vector2D): Vector2D;
+        toString(): string;
+        abs(): Vector2D;
+    }
+    class Line2D extends CxG {
+        normal: Vector2D;
+        w: number;
+        constructor(normal: Vector2D, w: number);
+        static fromPoints(p1: Vector2D, p2: Vector2D): Line2D;
+        reverse(): Line2D;
+        equals(l: Line2D): boolean;
+        origin(): Vector2D;
+        direction(): Vector2D;
+        xAtY(y: number): number;
+        absDistanceToPoint(point: Vector2D): number;
+        intersectWithLine(line2d: Line2D): Vector2D;
+        transform(matrix4x4: Matrix4x4): Line2D;
+    }
+    class Line3D extends CxG {
+        point: Vector3D;
+        direction: Vector3D;
+        constructor(point: Vector3D, direction: Vector3D);
+        static fromPoints(p1: Vector3D, p2: Vector3D): Line3D;
+        static fromPlanes(p1: Plane, p2: Plane): Line3D;
+        intersectWithPlane(plane: Plane): Vector3D;
+        clone(): Line3D;
+        reverse(): Line3D;
+        transform(matrix4x4: Matrix4x4): Line3D;
+        closestPointOnLine(point: Vector3D): Vector3D;
+        distanceToPoint(point: Vector3D): number;
+        equals(line3d: Line3D): boolean;
+    }
+    class OrthoNormalBasis extends CxG {
+        v: Vector3D;
+        u: Vector3D;
+        plane: Plane;
+        planeorigin: Vector3D;
+        constructor(plane: Plane, rightvector?: Vector3D);
+        static GetCartesian(xaxisid: string, yaxisid: string): OrthoNormalBasis;
+        static Z0Plane(): OrthoNormalBasis;
+        getProjectionMatrix(): Matrix4x4;
+        getInverseProjectionMatrix(): Matrix4x4;
+        to2D(vec3: Vector3D): Vector2D;
+        to3D(vec2: Vector2D): Vector3D;
+        line3Dto2D(line3d: Line3D): Line2D;
+        line2Dto3D(line2d: Line2D): Line3D;
+        transform(matrix4x4: Matrix4x4): OrthoNormalBasis;
+    }
+    function interpolateBetween2DPointsForY(point1: Vector2D, point2: Vector2D, y: number): number;
+    function reTesselateCoplanarPolygons(sourcepolygons: CSG.Polygon[], destpolygons: CSG.Polygon[]): void;
+    class fuzzyFactory {
+        multiplier: number;
+        lookuptable: any;
+        constructor(numdimensions: number, tolerance: number);
+        lookupOrCreate(els: any, creatorCallback: any): any;
+    }
+    class fuzzyCSGFactory {
+        vertexfactory: fuzzyFactory;
+        planefactory: fuzzyFactory;
+        polygonsharedfactory: any;
+        constructor();
+        getPolygonShared(sourceshared: Polygon.Shared): Polygon.Shared;
+        getVertex(sourcevertex: Vertex): Vertex;
+        getPlane(sourceplane: Plane): Plane;
+        getPolygon(sourcepolygon: Polygon): Polygon;
+        getCSG(sourcecsg: CSG): CSG;
+    }
+    var staticTag: number;
+    function getTag(): number;
+    class Properties {
+        cube: Properties;
+        center: any;
+        facecenters: any[];
+        roundedCube: Properties;
+        cylinder: Properties;
+        start: any;
+        end: any;
+        facepointH: any;
+        facepointH90: any;
+        sphere: Properties;
+        facepoint: any;
+        roundedCylinder: any;
+        _transform(matrix4x4: Matrix4x4): Properties;
+        _merge(otherproperties: Properties): Properties;
+        static transformObj(source: any, result: any, matrix4x4: Matrix4x4): void;
+        static cloneObj(source: any, result: any): void;
+        static addFrom(result: any, otherproperties: Properties): void;
+    }
+    class Connector extends CxG {
+        point: Vector3D;
+        axisvector: Vector3D;
+        normalvector: Vector3D;
+        constructor(point: number[], axisvector: Vector3D, normalvector: number[]);
+        constructor(point: number[], axisvector: number[], normalvector: number[]);
+        constructor(point: number[], axisvector: number[], normalvector: Vector3D);
+        constructor(point: Vector3D, axisvector: number[], normalvector: Vector3D);
+        constructor(point: Vector3D, axisvector: number[], normalvector: number[]);
+        constructor(point: Vector3D, axisvector: Vector3D, normalvector: Vector3D);
+        normalized(): Connector;
+        transform(matrix4x4: Matrix4x4): Connector;
+        getTransformationTo(other: Connector, mirror: boolean, normalrotation: number): Matrix4x4;
+        axisLine(): Line3D;
+        extend(distance: number): Connector;
+    }
+    class ConnectorList {
+        connectors_: Connector[];
+        closed: boolean;
+        constructor(connectors: Connector[]);
+        static defaultNormal: number[];
+        static fromPath2D(path2D: CSG.Path2D, arg1: any, arg2: any): ConnectorList;
+        static _fromPath2DTangents(path2D: any, start: any, end: any): ConnectorList;
+        static _fromPath2DExplicit(path2D: any, angleIsh: any): ConnectorList;
+        setClosed(bool: boolean): void;
+        appendConnector(conn: Connector): void;
+        followWith(cagish: any): CSG;
+        verify(): void;
+    }
+    interface IRadiusOptions {
+        radius?: number;
+        resolution?: number;
+    }
+    interface ICircleOptions extends IRadiusOptions {
+        center?: Vector2D | number[];
+    }
+    interface IArcOptions extends ICircleOptions {
+        startangle?: number;
+        endangle?: number;
+        maketangent?: boolean;
+    }
+    interface IEllpiticalArcOptions extends IRadiusOptions {
+        clockwise?: boolean;
+        large?: boolean;
+        xaxisrotation?: number;
+        xradius?: number;
+        yradius?: number;
+    }
+    interface IRectangleOptions {
+        center?: Vector2D;
+        corner1?: Vector2D;
+        corner2?: Vector2D;
+        radius?: Vector2D;
+    }
+    interface IRoundRectangleOptions {
+        roundradius: number;
+        resolution?: number;
+    }
+    class Path2D extends CxG {
+        closed: boolean;
+        points: Vector2D[];
+        lastBezierControlPoint: Vector2D;
+        constructor(points: number[], closed?: boolean);
+        constructor(points: Vector2D[], closed?: boolean);
+        static arc(options: IArcOptions): Path2D;
+        concat(otherpath: Path2D): Path2D;
+        appendPoint(point: Vector2D): Path2D;
+        appendPoints(points: Vector2D[]): Path2D;
+        close(): Path2D;
+        rectangularExtrude(width: number, height: number, resolution: number): CSG;
+        expandToCAG(pathradius: number, resolution: number): CAG;
+        innerToCAG(): CAG;
+        transform(matrix4x4: Matrix4x4): Path2D;
+        appendBezier(controlpoints: any, options: any): Path2D;
+        appendArc(endpoint: Vector2D, options: IEllpiticalArcOptions): Path2D;
+    }
+}
+declare class CAG extends CxG implements ICenter {
+    sides: CAG.Side[];
+    isCanonicalized: boolean;
+    constructor();
+    static fromSides(sides: CAG.Side[]): CAG;
+    static fromPoints(points: CSG.Vector2D[]): CAG;
+    static fromPointsNoCheck(points: CSG.Vector2D[]): CAG;
+    static fromFakeCSG(csg: CSG): CAG;
+    static linesIntersect(p0start: CSG.Vector2D, p0end: CSG.Vector2D, p1start: CSG.Vector2D, p1end: CSG.Vector2D): boolean;
+    static circle(options: CSG.ICircleOptions): CAG;
+    static rectangle(options: CSG.IRectangleOptions): CAG;
+    static roundedRectangle(options: any): CAG;
+    static fromCompactBinary(bin: any): CAG;
+    toString(): string;
+    _toCSGWall(z0: any, z1: any): CSG;
+    _toVector3DPairs(m: CSG.Matrix4x4): CSG.Vector3D[][];
+    _toPlanePolygons(options: any): CSG.Polygon[];
+    _toWallPolygons(options: any): any[];
+    union(cag: CAG[]): CAG;
+    union(cag: CAG): CAG;
+    subtract(cag: CAG[]): CAG;
+    subtract(cag: CAG): CAG;
+    intersect(cag: CAG[]): CAG;
+    intersect(cag: CAG): CAG;
+    transform(matrix4x4: CSG.Matrix4x4): CAG;
+    area(): number;
+    flipped(): CAG;
+    getBounds(): CSG.Vector2D[];
+    isSelfIntersecting(): boolean;
+    expandedShell(radius: number, resolution: number): CAG;
+    expand(radius: number, resolution: number): CAG;
+    contract(radius: number, resolution: number): CAG;
+    extrudeInOrthonormalBasis(orthonormalbasis: CSG.OrthoNormalBasis, depth: number, options?: any): CSG;
+    extrudeInPlane(axis1: any, axis2: any, depth: any, options: any): CSG;
+    extrude(options: CAG_extrude_options): CSG;
+    rotateExtrude(options: any): CSG;
+    check(): void;
+    canonicalized(): CAG;
+    toCompactBinary(): {
+        'class': string;
+        sideVertexIndices: Uint32Array;
+        vertexData: Float64Array;
+    };
+    getOutlinePaths(): CSG.Path2D[];
+    overCutInsideCorners(cutterradius: any): CAG;
+    center(cAxes: string[]): CxG;
+    toDxf(): Blob;
+    static PathsToDxf(paths: CSG.Path2D[]): Blob;
+}
+declare module CAG {
+    class Vertex {
+        pos: CSG.Vector2D;
+        tag: number;
+        constructor(pos: CSG.Vector2D);
+        toString(): string;
+        getTag(): number;
+    }
+    class Side extends CxG {
+        vertex0: Vertex;
+        vertex1: Vertex;
+        tag: number;
+        constructor(vertex0: Vertex, vertex1: Vertex);
+        static _fromFakePolygon(polygon: CSG.Polygon): Side;
+        toString(): string;
+        toPolygon3D(z0: any, z1: any): CSG.Polygon;
+        transform(matrix4x4: CSG.Matrix4x4): Side;
+        flipped(): Side;
+        direction(): CSG.Vector2D;
+        getTag(): number;
+        lengthSquared(): number;
+        length(): number;
+    }
+    class fuzzyCAGFactory {
+        vertexfactory: CSG.fuzzyFactory;
+        constructor();
+        getVertex(sourcevertex: Vertex): Vertex;
+        getSide(sourceside: Side): Side;
+        getCAG(sourcecag: CAG): CAG;
+    }
+}
+interface CAG_extrude_options {
+    offset?: number[];
+    twistangle?: number;
+    twiststeps?: number;
+}
+declare module CSG {
+    class Polygon2D extends CAG {
+        constructor(points: Vector2D[]);
+    }
+}

README.md

@@ -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/DefinitelyTyped/DefinitelyTyped.png?branch=master)](https://travis-ci.org/DefinitelyTyped/DefinitelyTyped)
 
 [![Join the chat at https://gitter.im/borisyankov/DefinitelyTyped](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/borisyankov/DefinitelyTyped?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -16,7 +16,7 @@ Include a line like this:
 
 ## Contributions
 
-DefinitelyTyped only works because of contributions by users like you! 
+DefinitelyTyped only works because of contributions by users like you!
 
 Please see the [contribution guide](http://definitelytyped.org/guides/contributing.html) on how to contribute to DefinitelyTyped.
 
@@ -34,7 +34,7 @@ Please see the [contribution guide](http://definitelytyped.org/guides/contributi
 
 Here is are the [currently requested definitions](https://github.com/borisyankov/DefinitelyTyped/labels/Definition%3ARequest).
 
-## Licence
+## License
 
 This project is licensed under the MIT license.
 

abs/abs-tests.ts

@@ -0,0 +1,5 @@
+/// <reference path="./abs.d.ts" />
+
+import Abs from 'abs';
+
+const x: string = Abs('/foo');

abs/abs.d.ts

@@ -0,0 +1,14 @@
+// Type definitions for abs 1.1.0
+// Project: https://github.com/IonicaBizau/node-abs
+// Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "abs" {
+	/**
+	 * Compute the absolute path of an input.
+	 * @param input The input path.
+	 */
+	function Abs(input: string): string;
+
+	export default Abs;
+}

absolute/absolute-tests.ts

@@ -0,0 +1,5 @@
+/// <reference path="./absolute.d.ts" />
+
+import absolute from 'absolute';
+
+const x: boolean = absolute('/home/foo');

absolute/absolute.d.ts

@@ -0,0 +1,13 @@
+// Type definitions for absolute 0.0.1
+// Project: https://github.com/bahamas10/node-absolute
+// Definitions by: Aya Morisawa <https://github.com/AyaMorisawa>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare module "absolute" {
+	/**
+	 * Test if a path is absolute
+	 */
+	function absolute(path: string): boolean;
+
+	export default absolute;
+}

ace/ace.d.ts.tscparams

@@ -1 +0,0 @@
-

ace/tests/ace-editor_text_edit-tests.ts.tscparams

@@ -1 +0,0 @@
-

ace/tests/ace-range-tests.ts.tscparams

@@ -1 +0,0 @@
-

ace/tests/ace-search-tests.ts.tscparams

@@ -1 +0,0 @@
-

acorn/acorn.d.ts

@@ -9,6 +9,7 @@ declare module acorn {
     var version: string;
     function parse(input: string, options?: Options): ESTree.Program;
     function parseExpressionAt(input: string, pos: number, options?: Options): ESTree.Expression;
+    function getLineInfo(input: string, offset: number): ESTree.Position;
     var defaultOptions: Options;
 
     interface TokenType {

adm-zip/adm-zip-tests.ts

@@ -1,10 +1,9 @@
 /// <reference path="adm-zip.d.ts" />
 import AdmZip = require("adm-zip");
 
-
 // reading archives
 var zip = new AdmZip("./my_file.zip");
-var zipEntries = zip.getEntries(); // an array of ZipEntry records
+var zipEntries: AdmZip.IZipEntry[] = zip.getEntries(); // an array of ZipEntry records
 
 zipEntries.forEach(function (zipEntry) {
     console.log(zipEntry.toString()); // outputs zip entries information
@@ -31,3 +30,32 @@ zip.addLocalFile("/home/me/some_picture.png");
 var willSendthis = zip.toBuffer();
 // or write everything to disk
 zip.writeZip(/*target file name*/"/home/me/files.zip");
+
+function processZipEntry(zipEntry: AdmZip.IZipEntry) {
+    console.log('comment', zipEntry.comment);
+}
+
+//tests taken from examples at https://github.com/cthackers/adm-zip/wiki/ADM-ZIP
+import Zip = require("adm-zip");
+// loads and parses existing zip file local_file.zip
+var zip = new Zip("local_file.zip"); 
+// creates new in memory zip
+zip = new Zip();
+// loads and parses existing zip file local_file.zip
+zip = new Zip("local_file.zip"); 
+// get all entries and iterate them
+zip.getEntries().forEach((entry) => {
+    var entryName = entry.entryName;
+    var decompressedData = zip.readFile(entry); // decompressed buffer of the entry
+    console.log(zip.readAsText(entry)); // outputs the decompressed content of the entry  
+});
+
+// will extract the file myfile.txt from the archive to /home/user/folder/subfolder/myfile.txt
+zip.extractEntryTo("folder/subfolder/myfile.txt", "/home/user/", true, true);
+
+// will extract the file myfile.txt from the archive to /home/user/myfile.txt
+zip.extractEntryTo("folder/subfolder/myfile.txt", "/home/user/", false, true);
+
+function isAdmZipEntry(obj: any): obj is AdmZip.IZipEntry {
+  return obj !== null && typeof obj === "object" && typeof obj['entryName'] === 'string';
+}

adm-zip/adm-zip.d.ts

@@ -5,8 +5,8 @@
 
 /// <reference path="../node/node.d.ts" />
 
-declare module AdmZip {
-    class ZipFile {
+declare module "adm-zip" {
+    class AdmZip {
         /**
          * Create a new, empty archive.
          */
@@ -28,7 +28,7 @@ declare module AdmZip {
          * @param entry ZipEntry object
          * @return Buffer or Null in case of error
          */
-        readFile(entry: IZipEntry): Buffer;
+        readFile(entry: AdmZip.IZipEntry): Buffer;
         /**
          * Asynchronous readFile
          * @param entry String with the full path of the entry
@@ -41,7 +41,7 @@ declare module AdmZip {
          * @param callback Called with a Buffer or Null in case of error
          * @return Buffer or Null in case of error
          */
-        readFileAsync(entry: IZipEntry, callback: (data: Buffer, err: string) => any): void;
+        readFileAsync(entry: AdmZip.IZipEntry, callback: (data: Buffer, err: string) => any): void;
         /**
          * Extracts the given entry from the archive and returns the content as
          * plain text in the given encoding
@@ -57,7 +57,7 @@ declare module AdmZip {
          * @param encoding Optional. If no encoding is specified utf8 is used
          * @return String
          */
-        readAsText(fileName: IZipEntry, encoding?: string): string;
+        readAsText(fileName: AdmZip.IZipEntry, encoding?: string): string;
         /**
          * Asynchronous readAsText
          * @param entry String with the full path of the entry
@@ -71,7 +71,7 @@ declare module AdmZip {
          * @param callback Called with the resulting string.
          * @param encoding Optional. If no encoding is specified utf8 is used
          */
-        readAsTextAsync(fileName: IZipEntry, callback: (data: string) => any, encoding?: string): void;
+        readAsTextAsync(fileName: AdmZip.IZipEntry, callback: (data: string) => any, encoding?: string): void;
         /**
          * Remove the entry from the file or the entry and all its nested directories
          * and files if the given entry is a directory
@@ -83,7 +83,7 @@ declare module AdmZip {
          * and files if the given entry is a directory
          * @param entry A ZipEntry object.
          */
-        deleteFile(entry: IZipEntry): void;
+        deleteFile(entry: AdmZip.IZipEntry): void;
         /**
          * Adds a comment to the zip. The zip must be rewritten after
          * adding the comment.
@@ -110,7 +110,7 @@ declare module AdmZip {
          * @param entry ZipEntry object.
          * @param comment The comment to add to the entry.
          */
-        addZipEntryComment(entry: IZipEntry, comment: string): void;
+        addZipEntryComment(entry: AdmZip.IZipEntry, comment: string): void;
         /**
          * Returns the comment of the specified entry.
          * @param entry String with the full path of the entry.
@@ -122,7 +122,7 @@ declare module AdmZip {
          * @param entry ZipEntry object.
          * @return String The comment of the specified entry.
          */
-        getZipEntryComment(entry: IZipEntry): string;
+        getZipEntryComment(entry: AdmZip.IZipEntry): string;
         /**
          * Updates the content of an existing entry inside the archive. The zip
          * must be rewritten after updating the content
@@ -136,7 +136,7 @@ declare module AdmZip {
          * @param entry ZipEntry object.
          * @param content The entry's new contents.
          */
-        updateFile(entry: IZipEntry, content: Buffer): void;
+        updateFile(entry: AdmZip.IZipEntry, content: Buffer): void;
         /**
          * Adds a file from the disk to the archive.
          * @param localPath Path to a file on disk.
@@ -167,14 +167,14 @@ declare module AdmZip {
          * Returns an array of ZipEntry objects representing the files and folders
          * inside the archive
          */
-        getEntries(): IZipEntry[];
+        getEntries(): AdmZip.IZipEntry[];
         /**
          * Returns a ZipEntry object representing the file or folder specified by
          * ``name``.
          * @param name Name of the file or folder to retrieve.
          * @return ZipEntry The entry corresponding to the name.
          */
-        getEntry(name: string): IZipEntry;
+        getEntry(name: string): AdmZip.IZipEntry;
         /**
          * Extracts the given entry to the given targetPath.
          * If the entry is a directory inside the archive, the entire directory and
@@ -203,7 +203,7 @@ declare module AdmZip {
          *   will be overwriten if this is true. Default is FALSE
          * @return Boolean
          */
-        extractEntryTo(entryPath: IZipEntry, targetPath: string, maintainEntryPath?: boolean, overwrite?: boolean): boolean;
+        extractEntryTo(entryPath: AdmZip.IZipEntry, targetPath: string, maintainEntryPath?: boolean, overwrite?: boolean): boolean;
         /**
          * Extracts the entire archive to the given location
          * @param targetPath Target location
@@ -225,76 +225,75 @@ declare module AdmZip {
         toBuffer(): Buffer;
     }
 
-    /**
-     * The ZipEntry is more than a structure representing the entry inside the
-     * zip file. Beside the normal attributes and headers a entry can have, the
-     * class contains a reference to the part of the file where the compressed
-     * data resides and decompresses it when requested. It also compresses the
-     * data and creates the headers required to write in the zip file.
-     */
-    interface IZipEntry {
+    module AdmZip {    
         /**
-         * Represents the full name and path of the file
+         * The ZipEntry is more than a structure representing the entry inside the
+         * zip file. Beside the normal attributes and headers a entry can have, the
+         * class contains a reference to the part of the file where the compressed
+         * data resides and decompresses it when requested. It also compresses the
+         * data and creates the headers required to write in the zip file.
          */
-        entryName: string;
-        rawEntryName: Buffer;
-        /**
-         * Extra data associated with this entry.
-         */
-        extra: Buffer;
-        /**
-         * Entry comment.
-         */
-        comment: string;
-        name: string;
-        /**
-         * Read-Only property that indicates the type of the entry.
-         */
-        isDirectory: boolean;
-        /**
-         * Get the header associated with this ZipEntry.
-         */
-        header: Buffer;
-        /**
-         * Retrieve the compressed data for this entry. Note that this may trigger
-         * compression if any properties were modified.
-         */
-        getCompressedData(): Buffer;
-        /**
-         * Asynchronously retrieve the compressed data for this entry. Note that
-         * this may trigger compression if any properties were modified.
-         */
-        getCompressedDataAsync(callback: (data: Buffer) => void): void;
-        /**
-         * Set the (uncompressed) data to be associated with this entry.
-         */
-        setData(value: string): void;
-        /**
-         * Set the (uncompressed) data to be associated with this entry.
-         */
-        setData(value: Buffer): void;
-        /**
-         * Get the decompressed data associated with this entry.
-         */
-        getData(): Buffer;
-        /**
-         * Asynchronously get the decompressed data associated with this entry.
-         */
-        getDataAsync(callback: (data: Buffer) => void): void;
-        /**
-         * Returns the CEN Entry Header to be written to the output zip file, plus
-         * the extra data and the entry comment.
-         */
-        packHeader(): Buffer;
-        /**
-         * Returns a nicely formatted string with the most important properties of
-         * the ZipEntry.
-         */
-        toString(): string;
+        interface IZipEntry {
+            /**
+             * Represents the full name and path of the file
+             */
+            entryName: string;
+            rawEntryName: Buffer;
+            /**
+             * Extra data associated with this entry.
+             */
+            extra: Buffer;
+            /**
+             * Entry comment.
+             */
+            comment: string;
+            name: string;
+            /**
+             * Read-Only property that indicates the type of the entry.
+             */
+            isDirectory: boolean;
+            /**
+             * Get the header associated with this ZipEntry.
+             */
+            header: Buffer;
+            /**
+             * Retrieve the compressed data for this entry. Note that this may trigger
+             * compression if any properties were modified.
+             */
+            getCompressedData(): Buffer;
+            /**
+             * Asynchronously retrieve the compressed data for this entry. Note that
+             * this may trigger compression if any properties were modified.
+             */
+            getCompressedDataAsync(callback: (data: Buffer) => void): void;
+            /**
+             * Set the (uncompressed) data to be associated with this entry.
+             */
+            setData(value: string): void;
+            /**
+             * Set the (uncompressed) data to be associated with this entry.
+             */
+            setData(value: Buffer): void;
+            /**
+             * Get the decompressed data associated with this entry.
+             */
+            getData(): Buffer;
+            /**
+             * Asynchronously get the decompressed data associated with this entry.
+             */
+            getDataAsync(callback: (data: Buffer) => void): void;
+            /**
+             * Returns the CEN Entry Header to be written to the output zip file, plus
+             * the extra data and the entry comment.
+             */
+            packHeader(): Buffer;
+            /**
+             * Returns a nicely formatted string with the most important properties of
+             * the ZipEntry.
+             */
+            toString(): string;
+        }
     }
-}
 
-declare module "adm-zip" {
-    import zipFile = AdmZip.ZipFile;
-    export = zipFile;
+    export = AdmZip;
 }

ag-grid/ag-grid-tests.ts

@@ -0,0 +1,137 @@
+/// <reference path="ag-grid" />
+
+checkGridOptions(<ag.grid.GridOptions>{});
+checkColDef(<ag.grid.ColDef>{});
+
+function checkGridOptions(gridOptions: ag.grid.GridOptions): void {
+
+    gridOptions.virtualPaging = true;
+    gridOptions.toolPanelSuppressPivot = true;
+    gridOptions.toolPanelSuppressValues = true;
+    gridOptions.rowsAlreadyGrouped = true;
+    gridOptions.suppressRowClickSelection = true;
+    gridOptions.suppressCellSelection = true;
+    gridOptions.sortingOrder = ['asc','desc'];
+    gridOptions.suppressMultiSort = true;
+    gridOptions.suppressHorizontalScroll = true;
+    gridOptions.unSortIcon = true;
+    gridOptions.rowHeight = 0;
+    gridOptions.rowBuffer = 0;
+    gridOptions.enableColResize = true;
+    gridOptions.enableCellExpressions = true;
+    gridOptions.enableSorting = true;
+    gridOptions.enableServerSideSorting = true;
+    gridOptions.enableFilter = true;
+    gridOptions.enableServerSideFilter = true;
+    gridOptions.colWidth = 0;
+    gridOptions.suppressMenuHide = true;
+    gridOptions.singleClickEdit = true;
+    gridOptions.debug = true;
+    gridOptions.icons = {};
+    gridOptions.angularCompileRows = true;
+    gridOptions.angularCompileFilters = true;
+    gridOptions.angularCompileHeaders = true;
+    gridOptions.localeText = {};
+    gridOptions.localeTextFunc = function() {}
+    gridOptions.suppressScrollLag = true;
+    gridOptions.groupSuppressAutoColumn = true;
+    gridOptions.groupSelectsChildren = true;
+    gridOptions.groupHidePivotColumns = true;
+    gridOptions.groupIncludeFooter = true;
+    gridOptions.groupUseEntireRow = true;
+    gridOptions.groupSuppressRow = true;
+    gridOptions.groupSuppressBlankHeader = true;
+    gridOptions.forPrint = true;
+    gridOptions.groupColumnDef = {};
+    gridOptions.context = {};
+    gridOptions.rowStyle = {color: 'red'};
+    gridOptions.rowClass = 'green';
+    gridOptions.groupDefaultExpanded = false;
+    gridOptions.slaveGrids = [];
+    gridOptions.rowSelection = 'single';
+    gridOptions.rowDeselection = true;
+    gridOptions.rowData = [];
+    gridOptions.floatingTopRowData = [];
+    gridOptions.floatingBottomRowData = [];
+    gridOptions.showToolPanel = true;
+    gridOptions.groupKeys = ['a','b']
+    gridOptions.groupAggFields = ['a','b']
+    gridOptions.columnDefs = [];
+    gridOptions.datasource = {};
+    gridOptions.pinnedColumnCount = 0;
+    gridOptions.groupHeaders = true;
+    gridOptions.headerHeight = 0;
+    gridOptions.groupRowInnerRenderer = function(params) {};
+    gridOptions.groupRowRenderer = {};
+    gridOptions.isScrollLag = function() {return true;}
+    gridOptions.isExternalFilterPresent = function() { return true; };
+    gridOptions.doesExternalFilterPass = function(node: ag.grid.RowNode) { return false; };
+    gridOptions.getRowStyle = function() {};
+    gridOptions.getRowClass = function() {};
+    gridOptions.headerCellRenderer = function() {};
+    gridOptions.groupAggFunction = function(nodes: any[]) {};
+    gridOptions.onReady = function(api: any) {};
+    gridOptions.onModelUpdated = function() {};
+    gridOptions.onCellClicked = function(params) {};
+    gridOptions.onCellDoubleClicked = function(params) {};
+    gridOptions.onCellContextMenu = function(params) {};
+    gridOptions.onCellValueChanged = function(params) {};
+    gridOptions.onCellFocused = function(params) {};
+    gridOptions.onRowSelected = function(params) {};
+    gridOptions.onSelectionChanged = function() {};
+    gridOptions.onBeforeFilterChanged = function() {};
+    gridOptions.onAfterFilterChanged = function() {};
+    gridOptions.onFilterModified = function() {};
+    gridOptions.onBeforeSortChanged = function() {};
+    gridOptions.onAfterSortChanged = function() {};
+    gridOptions.onVirtualRowRemoved = function(params) {};
+    gridOptions.onRowClicked = function(params) {};
+    gridOptions.api = null;
+    gridOptions.columnApi = null;
+
+}
+
+function checkColDef(colDef: ag.grid.ColDef): void {
+
+    colDef.sort = 'test';
+    colDef.sortedAt = 0;
+    colDef.sortingOrder = ['asc','desc'];
+    colDef.headerName = 'test';
+    colDef.field = 'test';
+    colDef.headerValueGetter = 'test';
+    colDef.colId = 'test';
+    colDef.hide = true;
+    colDef.headerTooltip = 'test';
+    colDef.valueGetter = 'test';
+    colDef.headerCellRenderer = {};
+    colDef.headerClass = 'test';
+    colDef.width = 0;
+    colDef.minWidth = 0;
+    colDef.maxWidth = 0;
+    colDef.cellClass = 'test';
+    colDef.cellStyle = {color: 'test'};
+    colDef.cellRenderer = function() {};
+    colDef.floatingCellRenderer = function() {};
+    colDef.aggFunc = 'test';
+    colDef.comparator = function() {};
+    colDef.checkboxSelection = true;
+    colDef.suppressMenu = true;
+    colDef.suppressSorting = true;
+    colDef.unSortIcon = true;
+    colDef.suppressSizeToFit = true;
+    colDef.suppressResize = true;
+    colDef.headerGroup = 'test';
+    colDef.headerGroupShow = 'test';
+    colDef.editable = true;
+    colDef.newValueHandler = function() {};
+    colDef.volatile = true;
+    colDef.template = 'test';
+    colDef.templateUrl = 'test';
+    colDef.filter = 'test';
+    colDef.filterParams = {};
+    colDef.onCellValueChanged = function() {};
+    colDef.onCellClicked = function() {};
+    colDef.onCellDoubleClicked = function() {};
+    colDef.onCellContextMenu = function() {};
+    colDef.cellClassRules = {};
+}

amcharts/AmCharts.d.ts

@@ -178,15 +178,15 @@ declare module AmCharts {
         /** You can trigger the animation of the pie chart. */
         animateAgain();
         /** You can trigger the click on a slice from outside. index - the number of a slice or Slice object. */
-        clickSlice(index);
+        clickSlice(index: number);
         /** Hides slice. index - the number of a slice or Slice object. */
-        hideSlice(index);
+        hideSlice(index: number);
         /** You can simulate roll-out of a slice from outside. index - the number of a slice or Slice object. */
-        rollOutSlice(index);
+        rollOutSlice(index: number);
         /** You can simulate roll-over a slice from outside. index - the number of a slice or Slice object. */
-        rollOverSlice(index);
+        rollOverSlice(index: number);
         /** Shows slice. index - the number of a slice or Slice object. */
-        showSlice(index);
+        showSlice(index: number);
 
         /** Adds event listener of the type "clickSlice" or "pullInSlice" or "pullOutSlice" to the object.
             @param type Always "clickSlice" or "pullInSlice" or "pullOutSlice".
@@ -311,22 +311,32 @@ declare module AmCharts {
 
 If you do not set properties such as dashLength, lineAlpha, lineColor, etc - values of the axis are used.*/
     class Guide {
+        /** If you set it to true, the guide will be displayed above the graphs. */
+        above: boolean;
         /** Radar chart only. Specifies angle at which guide should start. Affects only fills, not lines. */
         angle: number;
         /** Baloon fill color. */
         balloonColor: string;
         /** The text which will be displayed if the user rolls-over the guide. */
         balloonText: string;
+        /** Specifies if label should be bold or not. */
+        boldLabel: boolean;
         /** Category of the guide (in case the guide is for category axis). */
         category: string;
         /** Dash length. */
         dashLength: number;
         /** Date of the guide (in case the guide is for category axis and parseDates is set to true). */
         date: Date;
+        /** Works if a guide is added to CategoryAxis and this axis is non-date-based. If you set it to true, the guide will start (or be placed, if it's not a fill) on the beginning of the category cell and will end at the end of toCategory cell. */
+        expand: boolean;
         /** Fill opacity. Value range is 0 - 1. */
         fillAlpha: number;
         /** Fill color. */
         fillColor: string;
+        /** Font size of guide label. */
+        fontSize: string;
+        /** Unique id of a Guide. You don't need to set it, unless you want to. */
+        id: string;
         /** Specifies whether label should be placed inside or outside plot area. */
         inside: boolean;
         /** The label which will be displayed near the guide. */
@@ -339,6 +349,8 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         lineColor: string;
         /** Line thickness. */
         lineThickness: number;
+        /** Position of guide label. Possible values are "left" or "right" for horizontal axis and "top" or "bottom" for vertical axis.  */
+        position: string;
         /** Tick length. */
         tickLength: number;
         /** Radar chart only. Specifies angle at which guide should end. Affects only fills, not lines. */
@@ -351,6 +363,8 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         toValue: number;
         /** Value of the guide (in case the guide is for value axis). */
         value: number;
+        /** Value axis of a guide. As you can add guides directly to the chart, you might need to specify which which value axis should be used. */
+        valueAxis: ValueAxis;
     }
     /** ImagesSettings is a class which holds common settings of all MapImage objects. */
     class ImagesSettings {
@@ -381,7 +395,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Font size of a label. 
             @default 11
         */
-        labelFontSize: number;
+        labelfontSize: string;
         /** Position of the label. Allowed values are: left, right, top, bottom and middle. right */
         labelPosition: string;
         /** Label roll-over color. #00CC00 */
@@ -546,7 +560,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Hides event bullets. */
         hideStockEvents();
         /** Removes event listener from the object. */
-        removeListener(obj, type, handler);
+        removeListener(obj: any, type: string, handler: any);
         /** Removes panel from the stock chart. Requires stockChart.validateNow() method to be called after this action. */
         removePanel(panel: StockPanel);
         /** Shows event bullets. */
@@ -556,7 +570,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Method which forces the stock chart to rebuild. Should be called after properties are changed. */
         validateNow();
         /** Zooms chart to specified dates. startDate, endDate - Date objects. */
-        zoom(startDate, endDate);
+        zoom(startDate: Date, endDate: Date);
         /** Zooms out the chart. */
         zoomOut();
 
@@ -716,7 +730,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         */
         equalWidths: boolean;
         /** Font size. Will use chart's font size if not set. */
-        fontSize: number;
+        fontSize: string;
         /** Horizontal space between legend item and left/right border. */
         horizontalGap: number;
         /** The text which will be displayed in the legend. Tag [[title]] will be replaced with the title of the graph. [[title]] */
@@ -886,8 +900,17 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
     /** AmChart is a base class of all charts. It can not be instantiated explicitly. AmCoordinateChart, AmPieChart and AmMap extend AmChart class. */
     class AmChart {
     	/** used when constructing a chart with a theme */
-    	constructor(theme: any);
-    	/** Background color. You should set backgroundAlpha to >0 value in order background to be visible. We recommend setting background color directly on a chart's DIV instead of using this property. #FFFFFF */
+    	constructor(theme?: any);
+    	/** Specifies, if class names should be added to chart elements. */
+        addClassNames: boolean;
+        /** Array of Labels. Example of label object, with all possible properties:
+{"x": 20, "y": 20, "text": "this is label", "align": "left", "size": 12, "color": "#CC0000", "alpha": 1, "rotation": 0, "bold": true, "url": "http://www.amcharts.com"} */
+        allLabels: Label[];
+        /**  Set this to false if you don't want chart to resize itself whenever its parent container size changes. */
+        autoResize: boolean;
+        /** Opacity of background. Set it to >0 value if you want backgroundColor to work. However we recommend changing div's background-color style for changing background color. */
+        backgroundAlpha: number;
+        /** Background color. You should set backgroundAlpha to >0 value in order background to be visible. We recommend setting background color directly on a chart's DIV instead of using this property. #FFFFFF */
         backgroundColor: string;
         /** The chart creates AmBalloon class itself. If you want to customize balloon, get balloon instance using this property, and then change balloon's properties.  AmBalloon */
         balloon: AmBalloon;
@@ -895,32 +918,83 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         borderAlpha: number;
         /** Color of chart's border. You should set borderAlpha >0 in order border to be visible. We recommend setting border color directly on a chart's DIV instead of using this property. #000000 */
         borderColor: string;
+        /** This prefix is added to all class names which are added to all visual elements of a chart in case addClassNames is set to true. */
+        classNamePrefix: string;
         /** Text color. #000000 */
         color: string;
+        /** Non-commercial version only. Specifies position of link to amCharts site. Allowed values are: top-left, top-right, bottom-left and bottom-right.
+            @default 'top-left'
+        */
+        creditsPosition: string;
         /** Array of data objects, for example: [{country:"US", value:524},{country:"UK", value:624},{country:"Lithuania", value:824}]. You can have any number of fields and use any field names. In case of AmMap, data provider should be MapData object. */
         dataProvider: any[];
+        /** Decimal separator.
+            @Default . */
+        decimalSeparator: string;
+        /** Using this property you can add any additional information to SVG, like SVG filters or clip paths. The structure of this object should be identical to XML structure of a object you are adding, only in JSON format. */
+        defs: any;
+        /** Export config. Specifies how export to image/data export/print/annotate menu will look and behave. You can find a lot of examples in amcharts/plugins/export folder. */
+        export: ExportSettings;
         /** Font family. Verdana */
         fontFamily: string;
         /** Font size.
             @default 11
         */
-        fontSize: number;
-        /** Height of a chart. "100%" means the chart's height will be equal to it's container's (DIV) height and will resize if height of the container changes. Set a number instead of percents if your chart's size needs to be fixed.
-            @default 1
+        fontSize: string;
+        /** If you set this to true, the lines of the chart will be distorted and will produce hand-drawn effect. Try to adjust chart.handDrawScatter and chart.handDrawThickness properties for a more scattered result. 
+            @Default false
         */
-        height: any;
+        handDrawn: boolean;
+        /** Defines by how many pixels hand-drawn line (when handDrawn is set to true) will fluctuate.
+            @Default 2
+        */
+        handDrawScatter: number;
+        /** Defines by how many pixels line thickness will fluctuate (when handDrawn is set to true).
+            @Default 1
+        */
+        handDrawThickness: number;
+        /** Time, in milliseconds after which balloon is hidden if the user rolls-out of the object. Might be useful for AmMap to avoid balloon flickering while moving mouse over the areas. Note, this is not duration of fade-out. Duration of fade-out is set in AmBalloon class. 
+            @Default 150
+        */
+        hideBalloonTime: number;
+        /** Legend of a chart. */
+        legend: AmLegend;
         /** Reference to the div of the legend. */
         legendDiv: HTMLElement;
-        /** Object with precision, decimalSeparator and thousandsSeparator set which will be used for number formatting. Precision set to -1 means that values won't be rounded.  {precision:-1, decimalSeparator:'.', thousandsSeparator:','} */
-        numberFormatter: Object;
+        /** You can add listeners of events using this property. Example: listeners = [{"event":"dataUpdated", "method":handleEvent}]; */
+        listerns: Object[];
         /** This setting affects touch-screen devices only. If a chart is on a page, and panEventsEnabled are set to true, the page won't move if the user touches the chart first. If a chart is big enough and occupies all the screen of your touch device, the user won’t be able to move the page at all. That's why the default value is "false". If you think that selecting/panning the chart or moving/pinching the map is a primary purpose of your users, you should set panEventsEnabled to true. */
         panEventsEnabled: boolean;
-        /** Object with precision, decimalSeparator and thousandsSeparator set which will be used for formatting percent values. {precision:2, decimalSeparator:'.', thousandsSeparator:','} */
-        percentFormatter: Object;
+        /**  Specifies absolute or relative path to amCharts files, i.e. "amcharts/". (where all .js files are located)
+            If relative URLs are used, they will be relative to the current web page, displaying the chart.            
+            You can also set path globally, using global JavaScript variable AmCharts_path. If this variable is set, and "path" is not set in chart config, the chart will assume the path from the global variable. This allows setting amCharts path globally. I.e.:            
+            var AmCharts_path = "/libs/amcharts/";
+            "path" parameter will be used by the charts to locate it's files, like images, plugins or patterns.*/
+        path: string;     
+        /** Specifies path to the folder where images like resize grips, lens and similar are.
+            IMPORTANT: Since V3.14.12, you should use "path" to point to amCharts directory instead. The "pathToImages" will be automatically set and does not need to be in the chart config, unless you keep your images separately from other amCharts files. */
+        pathToImages: string;
+        /** Precision of percent values. -1 means percent values won't be rounded at all and show as they are. 
+            @default 2
+        */
+        percentPrecision: number;
+        /** Precision of values. -1 means values won't be rounded at all and show as they are. 
+            @Default 1*/
+        precision: number;
         /** Prefixes which are used to make big numbers shorter: 2M instead of 2000000, etc. Prefixes are used on value axes and in the legend. To enable prefixes, set usePrefixes property to true. [{number:1e+3,prefix:"k"},{number:1e+6,prefix:"M"},{number:1e+9,prefix:"G"},{number:1e+12,prefix:"T"},{number:1e+15,prefix:"P"},{number:1e+18,prefix:"E"},{number:1e+21,prefix:"Z"},{number:1e+24,prefix:"Y"}] */
         prefixesOfBigNumbers: any[];
         /** Prefixes which are used to make small numbers shorter: 2μ instead of 0.000002, etc. Prefixes are used on value axes and in the legend. To enable prefixes, set usePrefixes property to true. [{number:1e-24, prefix:"y"},{number:1e-21, prefix:"z"},{number:1e-18, prefix:"a"},{number:1e-15, prefix:"f"},{number:1e-12, prefix:"p"},{number:1e-9, prefix:"n"},{number:1e-6, prefix:"μ"},{number:1e-3, prefix:"m"}] */
         prefixesOfSmallNumbers: any[];
+        /** Theme of a chart. Config files of themes can be found in amcharts/themes/ folder. More info about using themes. */
+        theme: string;
+        /** Thousands separator. 
+            @default .
+        */
+        thousandsSeparator: string;
+        /** Array of Title objects. */
+        titles: Title[];
+        /** Type of a chart. Required when creating chart using JSON. Possible types are: serial, pie, xy, radar, funnel, gauge, map, stock. */
+        type: string;
         /** If true, prefixes will be used for big and small numbers. You can set arrays of prefixes via prefixesOfSmallNumbers and prefixesOfBigNumbers properties. */
         usePrefixes: boolean;
         /** Read-only. Indicates current version of a script. */
@@ -938,7 +1012,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             bold - specifies if text is bold (true/false),
             url - url
         */
-        addLabel(x: number, y: number, text: string, align: string, size, color: string, rotation, alpha: number, bold: boolean, url: string);
+        addLabel(x: number, y: number, text: string, align: string, size: number, color: string, rotation: number, alpha: number, bold: boolean, url: string);
         /** Adds a legend to the chart.
             By default, you don't need to create div for your legend, however if you want it to be positioned in some different way, you can create div anywhere you want and pass id or reference to your div as a second parameter.
             (NOTE: This method will not work on StockPanel.)
@@ -955,7 +1029,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         addLegend(legend: AmLegend, legendDiv: HTMLElement);
 
         /**   Adds title to the top of the chart. Pie, Radar positions are updated so that they won't overlap. Plot area of Serial/XY chart is also updated unless autoMargins property is set to false. You can add any number of titles - each of them will be placed in a new line. To remove titles, simply clear titles array: chart.titles = []; and call chart.validateNow() method. text - text of a title size - font size color - title color alpha - title opacity bold - boolean value indicating if title should be bold. */
-        addTitle(text, size, color, alpha, bold);
+        addTitle(text: string, size: number, color: string, alpha: number, bold: boolean);
         /** Clears the chart area, intervals, etc. */
         clear();
         /** Removes all labels added to the chart. */
@@ -996,34 +1070,22 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
     /** AmCoordinateChart is a base class of AmRectangularChart. It can not be instantiated explicitly. */
 
     class AmCoordinateChart extends AmChart {
+        /** Read-only. Array, holding processed chart's data. */
+        chartData: Object[];
         /** Specifies the colors of the graphs if the lineColor of a graph is not set.
             It there are more graphs then colors in this array, the chart picks random color.
             @default ['#FF6600', '#FCD202', '#B0DE09', '#0D8ECF', '#2A0CD0', '#CD0D74', '#CC0000', '#00CC00', '#0000CC', '#DDDDDD', '#999999', '#333333', '#990000'] */
-        colors: any[];
+        colors: string[];
         /** The array of graphs belonging to this chart.
             To add/remove graph use addGraph/removeGraph methods instead of adding/removing graphs directly to array.
         */
-        graphs: any[];
-        /** The opacity of plot area's border.
-            Value range is 0 - 1.
+        graphs: AmGraph[];
+        /** Specifies if grid should be drawn above the graphs or below. Will not work properly with 3D charts.
+            @default false
         */
-        plotAreaBorderAlpha: number;
-        /** The color of the plot area's border.
-            Note, the it is invisible by default, as plotAreaBorderAlpha default value is 0.
-            Set it to a value higher than 0 to make it visible.
-            @default #000000
-        */
-        plotAreaBorderColor: string;
-        /** Opacity of plot area.
-            Plural form is used to keep the same property names as our Flex charts'.
-            Flex charts can accept array of numbers to generate gradients.
-            Although you can set array here, only first value of this array will be used.
-        */
-        plotAreaFillAlphas: number;
-        /** You can set both one color if you need a solid color or array of colors to generate gradients, for example: ["#000000", "#0000CC"]
-            @default #FFFFFF
-        */
-        plotAreaFillColors: any;
+        gridAboveGraphs: boolean;
+        /** Instead of adding guides to the axes, you can push all of them to this array. In case guide has category or date defined, it will automatically will be assigned to the category axis. Otherwise to first value axis, unless you specify a different valueAxis for the guide. */
+        guides: Guide[];
         /** Specifies whether the animation should be sequenced or all objects should appear at once.
             @default true
         */
@@ -1053,6 +1115,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /**  Adds a graph to the chart.
          */
         addGraph(graph: AmGraph);
+        /** Adds a legend to the chart. By default, you don't need to create div for your legend, however if you want it to be positioned in some different way, you can create div anywhere you want and pass id or reference to your div as a second parameter. (NOTE: This method will not work on StockPanel.) */ 
         /** Adds value axis to the chart.
             One value axis is created automatically, so if you don't want to change anything or add more value axes, you don't need to add it.
         */
@@ -1186,16 +1249,16 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         startOnAxis: boolean;
 
         /** Number returns coordinate of a category. Works only if parseDates is false. If parseDates is true, use dateToCoordinate method. category - String */
-        categoryToCoordinate(category);
+        categoryToCoordinate(category: string);
 
         /** date - Date object Returns Date of the coordinate, in case parseDates is set to true and equalSpacing is set to false.  coordinate - Number */
-        coordinateToDate(coordinate);
+        coordinateToDate(coordinate: number);
 
         /** Number Returns coordinate of the date, in case parseDates is set to true. if parseDates is false, use categoryToCoordinate method. date - Date object */
-        dateToCoordinate(date);
+        dateToCoordinate(date: Date);
         
         /** Number Returns index of the category which is most close to specified coordinate. x - coordinate */
-        xToIndex(x);
+        xToIndex(x: number);
     }
 
     /** ChartScrollbar class displays chart scrollbar. Supported by AmSerialChart and AmXYChart.
@@ -1269,7 +1332,9 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
 
     /** AmRectangularChart is a base class of AmSerialChart and AmXYChart. It can not be instantiated explicitly.*/
     class AmRectangularChart extends AmCoordinateChart {
-        /** The angle of the 3D part of plot area. This creates a 3D effect (if the "depth3D" is > 0). */
+        /** The angle of the 3D part of plot area. This creates a 3D effect (if the "depth3D" is > 0). 
+            @default 0
+        */
         angle: number;
         /** Space left from axis labels/title to the chart's outside border, if autoMargins set to true.
             @default 10
@@ -1279,11 +1344,12 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             @default true
         */
         autoMargins: boolean;
-        /** Chart cursor. */
+        /** Cursor of a chart. */
         chartCursor: ChartCursor;
         /** Chart scrollbar. */
         chartScrollbar: ChartScrollbar;
-        /** The depth of the 3D part of plot area. This creates a 3D effect (if the "angle" is > 0). */
+        /** The depth of the 3D part of plot area. This creates a 3D effect (if the "angle" is > 0). 
+            @default 0*/
         depth3D: number;
         /** Number of pixels between the container's bottom border and plot area. This space can be used for bottom axis' values. If autoMargin is true and bottom side has axis, this property is ignored.
             @default 20
@@ -1297,18 +1363,66 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             @default 20
         */
         marginRight: number;
-        /** Flag which should be set to false if you need margins to be recalculated on next chart.validateNow() call. */
+        /** Flag which should be set to false if you need margins to be recalculated on next chart.validateNow() call. 
+            @default false
+        */
         marginsUpdated: boolean;
         /** Number of pixels between the container's top border and plot area. This space can be used for top axis' values. If autoMargin is true and top side has axis, this property is ignored.
             @default 20
         */
         marginTop: number;
+        /** The opacity of plot area's border. Value range is 0 - 1.
+            @default 0
+         */
+        plotAreaBorderAlpha: number;
+        /** The color of the plot area's border. Note, the it is invisible by default, as plotAreaBorderAlpha default value is 0. Set it to a value higher than 0 to make it visible. 
+            @default '#000000'*/
+        plotAreaBorderColor: string;
+        /** Opacity of plot area. Plural form is used to keep the same property names as our Flex charts'. Flex charts can accept array of numbers to generate gradients. Although you can set array here, only first value of this array will be used. 
+            @default 0
+        */
+        plotAreaFillAlphas: number;
+        /** You can set both one color if you need a solid color or array of colors to generate gradients, for example: ["#000000", "#0000CC"] 
+            @default '#FFFFFF'
+        */
+        plotAreaFillColors: any;
+        /** If you are using gradients to fill the plot area, you can use this property to set gradient angle. The only allowed values are horizontal and vertical: 0, 90, 180, 270. 
+            @default 0
+        */
+        plotAreaGradientAngle: number;
         /** Array of trend lines added to a chart. You can add trend lines to a chart using this array or access already existing trend lines */
-        trendLines: any[];
-        /** It's a simple object containing information about zoom-out button. Other available properties of this object are fontSize and color. color specifies text color of a button. {backgroundColor:'#b2e1ff',backgroundAlpha:1} */
-        zoomOutButton: Object;
+        trendLines: TrendLine[];
+        /** Opacity of zoom-out button background. 
+            @default 0
+        */
+        zoomOutButtonAlpha: number;
+        /** Zoom-out button background color.
+            @default '#e5e5e5'
+        */
+        zoomOutButtonColor: string;
+        /** Name of zoom-out button image. In the images folder there is another lens image, called lensWhite.png. You might want to have white lens when background is dark. Or you can simply use your own image.
+            @default lens.png
+        */
+        zoomOutButtonImage: string;
+        /** Size of zoom-out button image
+            @default: 17
+        */
+        zoomOutButtonImageSize: number;
+        /** Padding around the text and image.
+            @default: 8
+        */
+        zoomOutButtonPadding: number;
+        /** Opacity of zoom-out button background when mouse is over it.
+            @default: 1
+        */
+        zoomOutButtonRollOverAlpha: number;
         /** Text in the zoom-out button. Show all */
         zoomOutText: string;
+        
+        /** Adds a ChartCursor object to a chart */
+        addChartCursor(cursor: ChartCursor);
+        /** Adds a ChartScrollbar to a chart */
+        addChartScrollbar(scrollbar: ChartScrollbar);
         /** Adds a TrendLine to a chart.
             You should call chart.validateNow() after this method is called in order the trend line to be visible. */
         addTrendLine(trendLine: TrendLine);
@@ -1318,7 +1432,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         removeChartScrollbar();
         /** Removes a trend line from a chart. 
             You should call chart.validateNow() in order the changes to be visible. */
-        removeTrendLine;
+        removeTrendLine(trendLine: TrendLine);
     }
 
     /* Trend lines are straight lines indicating trends, might also be used for some different purposes. Can be used by Serial and XY charts. To add/remove trend line, use chart.addTrendLine(trendLine)/chart.removeTrendLine(trendLine) methods or simply pass array of trend lines: chart.trendLines = [trendLine1, trendLine2].
@@ -1395,7 +1509,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Hides cursor. */
         hideCursor();
         /** You can force cursor to appear at specified cateogry or date. */
-        showCursorAt(category);
+        showCursorAt(category: string);
         /** Adds event listener of the type "changed" to the object.
             @param type Always "changed".
             @param handler Dispatched when cursor position is changed. "index" is a series index over which chart cursors currently is. "zooming" specifies if user is currently zooming (is selecting) the chart. mostCloseGraph property is set only when oneBalloonOnly is set to true.*/
@@ -1439,20 +1553,26 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
             chart.write("chartdiv");
     */
     class AmSerialChart extends AmRectangularChart {
-    	/** Read-only. Chart creates category axis itself. If you want to change some properties, you should get this axis from the chart and set properties to this object. */
+    	/** Date format of the graph balloon (if chart parses dates and you don't use chartCursor).
+            @default 'MMM DD, YYYY'
+        */
+        balloonDateFormat: string;
+        /** Read-only. Chart creates category axis itself. If you want to change some properties, you should get this axis from the chart and set properties to this object. */
         categoryAxis: CategoryAxis;
         /** Category field name tells the chart the name of the field in your dataProvider object which will be used for category axis values. */
         categoryField: string;
-        /** Read-only. Array of SerialDataItem objects generated from dataProvider. */
-        chartData: any[];
         /** The gap in pixels between two columns of the same category.
             @default 5
         */
         columnSpacing: number;
-        /** Relative width of columns. Value range is 0 - 1. 0.8 */
+        /** Space between 3D stacked columns.
+            @default 0
+        */
+        columnSpacing3D: number;
+        /** Relative width of columns. Value range is 0 - 1.
+            @default 0.8
+        */
         columnWidth: number;
-        /** Array holding chart's data. */
-        dataProvider: any[];
         /** Read-only. If category axis parses dates endDate indicates date to which the chart is currently displayed. */
         endDate: Date;
         /** Read-only. Category index to which the chart is currently displayed. */
@@ -1461,8 +1581,14 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         maxSelectedSeries: number;
         /** The longest time span allowed to select (in milliseconds) for example, 259200000 will limit selection to 3 days. */
         maxSelectedTime: number;
-        /** The shortest time span allowed to select (in milliseconds) for example, 1000 will limit selection to 1 second. */
+        /** The shortest time span allowed to select (in milliseconds) for example, 1000 will limit selection to 1 second. 
+            @default 0
+        */
         minSelectedTime: number;
+        /** Specifies if scrolling of a chart with mouse wheel is enabled. If you press shift while rotating mouse wheel, the chart will zoom-in/out. */
+        mouseWheelScrollEnabled: boolean;
+        /** Specifies if zooming of a chart with mouse wheel is enabled. If you press shift while rotating mouse wheel, the chart will scroll. */
+        mouseWheelZoomEnabled: boolean;
         /** If you set this to true, the chart will be rotated by 90 degrees (the columns will become bars). */
         rotate: boolean;
         /** Read-only. If category axis parses dates startDate indicates date from which the chart is currently displayed. */
@@ -1475,15 +1601,15 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         zoomOutOnDataUpdate: boolean;
 
         /** Number Returns index of the specified category value. value - series (category value) which index you want to find. */
-        getCategoryIndexByValue(value);
+        getCategoryIndexByValue(value: number);
         /** Zooms out, charts shows all available data. */
         zoomOut();
         /** Zooms the chart by the value of the category axis. start - category value, String \\ end - category value, String */
-        zoomToCategoryValues(start, end);
+        zoomToCategoryValues(start: Date, end: Date);
         /** Zooms the chart from one date to another. start - start date, Date object \\ end - end date, Date object */
-        zoomToDates(start, end);
+        zoomToDates(start: Date, end: Date);
         /** Zooms the chart by the index of the category. start - start index, Number \\ end - end index, Number */
-        zoomToIndexes(start, end);
+        zoomToIndexes(start: Date, end: Date);
     }
 
     class PeriodSelector {
@@ -1522,7 +1648,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
        .
 @param handler - Dispatched when dates in period selector input fields are changed or user clicks on one of the predefined period buttons. */
 
-        addListener(type, handler: (e: {
+        addListener(type: string, handler: (e: {
             /** Always: "changed" */
 
             type: string;
@@ -1695,6 +1821,31 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         urlTarget: string;
     }
 
+    /** Creates a label on the chart which can be placed anywhere, multiple can be assigned. */
+    class Label {
+        /** @Default 'left' */
+        align: string;
+        /** @Default 1 */
+        alpha: number;
+        /** Specifies if label is bold or not. */
+        bold: boolean;
+        /** Color of a label */
+        color: string; 
+        /** Unique id of a Label. You don't need to set it, unless you want to. */
+        id: string;
+        /** Rotation angle. */
+        rotation: number;
+        /** Text size */
+        size: number;
+        /** Text of a label */
+        text: string;
+        /** URL which will be access if user clicks on a label. */
+        url: string;
+        /** X position of a label. */
+        x: number|string;
+        /** y position of a label. */
+        y: number|string;
+    }
     /** Common settings of legends. If you change a property after the chart is initialized, you should call stockChart.validateNow() method in order for it to work. If there is no default value specified, default value of StockLegend class will be used. */
     class LegendSettings {
         /** Alignment of legend entries. Possible values are: "left", "right" and "center". */
@@ -1807,7 +1958,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Balloon background color. Usually balloon background color is set by the chart. Only if "adjustBorderColor" is "true" this color will be used. #CC0000 */
         fillColor: string;
         /** Size of text in the balloon. Chart's fontSize is used by default. */
-        fontSize: number;
+        fontSize: string;
         /** Horizontal padding of the balloon.
             @default 8
         3*/
@@ -1865,7 +2016,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Fill color. Every second space between grid lines can be filled with color. Set fillAlpha to a value greater than 0 to see the fills. */
         fillColor: string;
         /** Text size. */
-        fontSize: number;
+        fontSize: string;
         /** Opacity of grid lines. */
         gridAlpha: number;
         /** Color of grid lines. */
@@ -1945,7 +2096,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         */
         enabled: boolean;
         /** Font size. */
-        fontSize: number;
+        fontSize: string;
         /** Specifies which graph will be displayed in the scrollbar. */
         graph: AmGraph;
         /** Graph fill opacity. */
@@ -2004,6 +2155,8 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         alphaField: string;
         /** Value balloon color. Will use graph or data item color if not set. */
         balloonColor: string;
+        /**	If you set some function, the graph will call it and pass GraphDataItem and AmGraph object to it. This function should return a string which will be displayed in a balloon.  */
+        balloonFunction(graphDataItem: GraphDataItem, amGraph: AmGraph): string; 
         /** Balloon text. You can use tags like [[value]], [[description]], [[percents]], [[open]], [[category]] [[value]] */
         balloonText: string;
         /** Specifies if the line graph should be placed behind column graphs */
@@ -2069,7 +2222,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** You can set another graph here and if fillAlpha is >0, the area from this graph to fillToGraph will be filled (instead of filling the area to the X axis). */
         fillToGraph: AmGraph;
         /** Size of value labels text. Will use chart's fontSize if not set. */
-        fontSize: number;
+        fontSize: string;
         /** Orientation of the gradient fills (only for "column" graph type). Possible values are "vertical" and "horizontal". vertical */
         gradientOrientation: string;
         /** Specifies whether the graph is hidden. Do not use this to show/hide the graph, use hideGraph(graph) and showGraph(graph) methods instead. */
@@ -2193,7 +2346,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Fill color. Every second space between grid lines can be filled with color. Set fillAlpha to a value greater than 0 to see the fills. #FFFFFF */
         fillColor: string;
         /** Size of value labels text. Will use chart's fontSize if not set. */
-        fontSize: number;
+        fontSize: string;
         /** Opacity of grid lines. 0.2 */
         gridAlpha: number;
         /** Color of grid lines. #000000 */
@@ -2247,7 +2400,7 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Color of axis title. Will use text color of chart if not set any. */
         titleColor: string;
         /** Font size of axis title. Will use font size of chart plus two pixels if not set any. */
-        titleFontSize: number;
+        titlefontSize: string;
 
         /** Adds guide to the axis. */
         addGuide(guide:Guide);
@@ -2269,24 +2422,43 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         durationUnits: Object;
         /** Radar chart only. Possible values are: "polygons" and "circles". Set "circles" for polar charts. polygons */
         gridType: string;
+        /** Unique id of value axis. It is not required to set it, unless you need to tell the graph which exact value axis it should use. */
+        id: string;
         /** Specifies whether guide values should be included when calculating min and max of the axis. */
         includeGuidesInMinMax: boolean;
         /** If true, the axis will include hidden graphs when calculating min and max values. */
         includeHidden: boolean;
         /** Specifies whether values on axis can only be integers or both integers and doubles. */
         integersOnly: boolean;
+        /** You can use this function to format Value axis labels. This function is called and these parameters are passed: labelFunction(value, valueText, valueAxis);
+Where value is numeric value, valueText is formatted string and valueAxis is a reference to valueAxis object. 
+
+If axis type is "date", labelFunction will pass different arguments:
+labelFunction(valueText, date, valueAxis)
+
+Your function should return string.*/
+        labelFunction(value: number, valueText: string, valueAxis: ValueAxis): string;
+        labelFunction(valueText: string, data: Date, valueAxis: ValueAxis): string;
         /** Specifies if this value axis' scale should be logarithmic. */
         logarithmic: boolean;
         /** Read-only. Maximum value of the axis. */
         max: number;
         /** If you don't want max value to be calculated by the chart, set it using this property. This value might still be adjusted so that it would be possible to draw grid at rounded intervals. */
         maximum: number;
+        /** If your value axis is date-based, you can specify maximum date of the axis. Can be set as date object, timestamp number or string if dataDateFormat is set. */
+        maximumData: Date;
         /** Read-only. Minimum value of the axis. */
         min: number;
         /** If you don't want min value to be calculated by the chart, set it using this property. This value might still be adjusted so that it would be possible to draw grid at rounded intervals. */
         minimum: number;
+        /** If your value axis is date-based, you can specify minimum date of the axis. Can be set as date object, timestamp number or string if dataDateFormat is set. */
+        minimumDate: Date;
         /** If set value axis scale (min and max numbers) will be multiplied by it. I.e. if set to 1.2 the scope of values will increase by 20%. */
         minMaxMultiplier: number;
+        /** Works with radar charts only. If you set it to “middle”, labels and data points will be placed in the middle between axes. */
+        pointPosition: string;
+        /** Possible values are: "top", "bottom", "left", "right". If axis is vertical, default position is "left". If axis is horizontal, default position is "bottom". */
+        position: string;
         /** Precision (number of decimals) of values. */
         precision: number;
         /** Radar chart only. Specifies if categories (axes' titles) should be displayed near axes)
@@ -2301,10 +2473,22 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         stackType: string;
         /** Read-only. Value difference between two grid lines. */
         step: number;
+        /** If you set minimum and maximum for your axis, chart adjusts them so that grid would start and end on the beginning and end of plot area and grid would be at equal intervals. If you set strictMinMax to true, the chart will not adjust minimum and maximum of value axis. */
+        strictMinMax: boolean;
         /** In case you synchronize one value axis with another, you need to set the synchronization multiplier. Use synchronizeWithAxis method to set with which axis it should be synced. */
         synchronizationMultiplier: number;
+        /** One value axis can be synchronized with another value axis. You can use both reference to your axis or id of the axis here. You should set synchronizationMultiplyer in order for this to work. */
+        synchronizeWith: ValueAxis;
         /** If this value axis is stacked and has columns, setting valueAxis.totalText = "[[total]]" will make it to display total value above the most-top column. */
         totalText: string;
+        /** Color of total text. */
+        totalTextColor: string;
+        /** Distance from data point to total text. */
+        totalTextOffset: number;
+        /** This allows you to have logarithmic value axis and have zero values in the data. You must set it to >0 value in order to work. */
+        treatZeroAs: number;
+        /** Type of value axis. If your values in data provider are dates and you want this axis to show dates instead of numbers, set it to "date". */
+        type: string;
         /** Unit which will be added to the value label. */
         unit: string;
         /** Position of the unit. Possible values are "left" and "right". right */
@@ -2314,20 +2498,23 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** If true, values will always be formatted using scientific notation (5e+8, 5e-8...) Otherwise only values bigger then 1e+21 and smaller then 1e-7 will be displayed in scientific notation. */
         useScientificNotation: boolean;
 
+        /** Adds guide to the axis. */
+        addGuide(guide: Guide);
         /** Adds event listener to the object.  type - string like 'axisChanged' (should be listed in 'events' section of this class or classes which extend this class). handler - function which is called when event happens */
-        addListener(type, handler);
+        addListener(type: string, handler: any);
         /** Number, - value of coordinate. Returns value of the coordinate.  coordinate - y or x coordinate, in pixels. */
-        coordinateToValue(coordinate);
+        coordinateToValue(coordinate: number);
         /** Number - coordinate Returns coordinate of the value in pixels. value - Number */
-        getCoordinate(value);
-        
+        getCoordinate(value: number);
+        /** Removes guide from the axis.*/
+        removeGuide(guide: Guide);
         /** Removes event listener from the object. */
-        removeListener(obj, type, handler);
+        removeListener(obj: any, type: string, handler: any);
         
         /** One value axis can be synchronized with another value axis. You should set synchronizationMultiplyer in order for this to work. */
         synchronizeWithAxis(axis:ValueAxis);
         /** XY Chart only. Zooms-in the axis to the provided values. */
-        zoomToValues(startValue, endValue);
+        zoomToValues(startValue: number, endValue: number);
 
         /** Adds event listener of the type "axisZoomed" to the object.
             @param type Always "axisZoomed".
@@ -2347,4 +2534,25 @@ If you do not set properties such as dashLength, lineAlpha, lineColor, etc - val
         /** Removes event listener from chart object. */
         removeListener(chart: AmChart, type: string, handler: any);
     }
-}
+    
+    class Title {
+        /** @default 1 */
+        alpha: number;
+        /** Specifies if the tile is bold or not. 
+            @default false*/
+        bold: boolean;
+        /** Text color of a title. */
+        color: string; 
+        /** Unique id of a Title. You don't need to set it, unless you want to. */
+        id: string;
+        /** Text size */
+        size: number;
+        /** Text of a label */
+        text: string;
+    }
+    class ExportSettings {
+        enabled: boolean;
+        libs: Object;
+        menu: Object;
+    }
+}

amqplib/amqplib-tests.ts

@@ -1,9 +1,11 @@
 /// <reference path="amqplib.d.ts" />
 
+// promise api tests
 import amqp = require("amqplib");
 
 var msg = "Hello World";
 
+// test promise api
 amqp.connect("amqp://localhost")
     .then(connection => {
         return connection.createChannel()
@@ -19,3 +21,47 @@ amqp.connect("amqp://localhost")
             .then(channel => channel.consume("myQueue", newMsg => console.log("New Message: " + newMsg.content.toString())))
             .ensure(() => connection.close());
     });
+
+// test promise api properties
+var amqpMessage: amqp.Message;
+amqpMessage.properties.contentType = "application/json";
+var amqpAssertExchangeOptions: amqp.Options.AssertExchange;
+var anqpAssertExchangeReplies: amqp.Replies.AssertExchange;
+
+
+// callback api tests
+import amqpcb = require("amqplib/callback_api");
+
+amqpcb.connect("amqp://localhost", (err, connection) => {
+    if(!err) {
+        connection.createChannel((err, channel) => {
+          if (!err) {
+              channel.assertQueue("myQueue", {}, (err, ok) => {
+                  if(!err) {
+                      channel.sendToQueue("myQueue", new Buffer(msg));
+                  }
+              });
+          }
+        });
+    }
+});
+
+amqpcb.connect("amqp://localhost", (err, connection) => {
+    if(!err) {
+        connection.createChannel((err, channel) => {
+          if (!err) {
+              channel.assertQueue("myQueue", {}, (err, ok) => {
+                  if(!err) {
+                      channel.consume("myQueue", newMsg => console.log("New Message: " + newMsg.content.toString()));
+                  }
+              });
+          }
+        });
+    }
+});
+
+// test callback api properties
+var amqpcbMessage: amqpcb.Message;
+amqpcbMessage.properties.contentType = "application/json";
+var amqpcbAssertExchangeOptions: amqpcb.Options.AssertExchange;
+var anqpcbAssertExchangeReplies: amqpcb.Replies.AssertExchange;

amqplib/amqplib.d.ts

@@ -1,22 +1,12 @@
 // Type definitions for amqplib 0.3.x
 // Project: https://github.com/squaremo/amqp.node
-// Definitions by: Michael Nahkies <https://github.com/mnahkies>
+// Definitions by: Michael Nahkies <https://github.com/mnahkies>, Ab Reitsma <https://github.com/abreits>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../when/when.d.ts" />
 /// <reference path="../node/node.d.ts" />
 
-declare module "amqplib" {
-
-    import events = require("events");
-    import when = require("when");
-
-    interface Connection extends events.EventEmitter {
-        close(): when.Promise<void>;
-        createChannel(): when.Promise<Channel>;
-        createConfirmChannel(): when.Promise<Channel>;
-    }
-
+declare module "amqplib/properties" {
     module Replies {
         interface Empty {
         }
@@ -25,6 +15,9 @@ declare module "amqplib" {
             messageCount: number;
             consumerCount: number;
         }
+        interface PurgeQueue {
+            messageCount: number;
+        }
         interface DeleteQueue {
             messageCount: number;
         }
@@ -73,7 +66,7 @@ declare module "amqplib" {
 
             contentType?: string;
             contentEncoding?: string;
-            headers?: Object;
+            headers?: any;
             priority?: number;
             correlationId?: string;
             replyTo?: string;
@@ -88,7 +81,7 @@ declare module "amqplib" {
             noAck?: boolean;
             exclusive?: boolean;
             priority?: number;
-            arguments?: Object;
+            arguments?: any;
         }
         interface Get {
             noAck?: boolean;
@@ -97,8 +90,24 @@ declare module "amqplib" {
 
     interface Message {
         content: Buffer;
-        fields: Object;
-        properties: Object;
+        fields: any;
+        properties: any;
+    }
+}
+
+declare module "amqplib" {
+
+    import events = require("events");
+    import when = require("when");
+    import shared = require("amqplib/properties")
+    export import Replies = shared.Replies;
+    export import Options = shared.Options;
+    export import Message = shared.Message;
+
+    interface Connection extends events.EventEmitter {
+        close(): when.Promise<void>;
+        createChannel(): when.Promise<Channel>;
+        createConfirmChannel(): when.Promise<Channel>;
     }
 
     interface Channel extends events.EventEmitter {
@@ -108,7 +117,7 @@ declare module "amqplib" {
         checkQueue(queue: string): when.Promise<Replies.AssertQueue>;
 
         deleteQueue(queue: string, options?: Options.DeleteQueue): when.Promise<Replies.DeleteQueue>;
-        purgeQueue(queue: string): when.Promise<Replies.DeleteQueue>;
+        purgeQueue(queue: string): when.Promise<Replies.PurgeQueue>;
 
         bindQueue(queue: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
         unbindQueue(queue: string, source: string, pattern: string, args?: any): when.Promise<Replies.Empty>;
@@ -142,3 +151,68 @@ declare module "amqplib" {
 
     function connect(url: string, socketOptions?: any): when.Promise<Connection>;
 }
+
+declare module "amqplib/callback_api" {
+
+    import events = require("events");
+    import shared = require("amqplib/properties")
+    export import Replies = shared.Replies;
+    export import Options = shared.Options;
+    export import Message = shared.Message;
+
+    interface Connection extends events.EventEmitter {
+        close(callback?: (err: any) => void): void;
+        createChannel(callback: (err: any, channel: Channel) => void): void;
+        createConfirmChannel(callback: (err: any, confirmChannel: ConfirmChannel) => void): void;
+    }
+
+    interface Channel extends events.EventEmitter {
+        close(callback: (err: any) => void): void;
+
+        assertQueue(queue?: string, options?: Options.AssertQueue, callback?: (err:any, ok: Replies.AssertQueue) => void): void;
+        checkQueue(queue: string, callback?: (err: any, ok: Replies.AssertQueue) => void): void;
+
+        deleteQueue(queue: string, options?: Options.DeleteQueue, callback?: (err:any, ok: Replies.DeleteQueue) => void): void;
+        purgeQueue(queue: string, callback?: (err:any, ok: Replies.PurgeQueue) => void): void;
+
+        bindQueue(queue: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
+        unbindQueue(queue: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
+
+        assertExchange(exchange: string, type: string, options?: Options.AssertExchange, callback?: (err: any, ok: Replies.AssertExchange) => void): void;
+        checkExchange(exchange: string, callback?: (err: any, ok: Replies.Empty) => void): void;
+
+        deleteExchange(exchange: string, options?: Options.DeleteExchange, callback?: (err: any, ok: Replies.Empty) => void): void;
+
+        bindExchange(destination: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
+        unbindExchange(destination: string, source: string, pattern: string, args?: any, callback?: (err: any, ok: Replies.Empty) => void): void;
+
+        publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish): boolean;
+        sendToQueue(queue: string, content: Buffer, options?: Options.Publish): boolean;
+
+        consume(queue: string, onMessage: (msg: Message) => any, options?: Options.Consume, callback?: (err: any, ok: Replies.Consume) => void): void;
+
+        cancel(consumerTag: string, callback?: (err: any, ok: Replies.Empty) => void): void;
+        get(queue: string, options?: Options.Get, callback?: (err: any, ok: Message | boolean) => void): void;
+
+        ack(message: Message, allUpTo?: boolean): void;
+        ackAll(): void;
+
+        nack(message: Message, allUpTo?: boolean, requeue?: boolean): void;
+        nackAll(requeue?: boolean): void;
+        reject(message: Message, requeue?: boolean): void;
+
+        prefetch(count: number, global?: boolean): void;
+        recover(callback?: (err: any, ok: Replies.Empty) => void): void;
+    }
+
+    interface ConfirmChannel extends Channel {
+        publish(exchange: string, routingKey: string, content: Buffer, options?: Options.Publish, callback?: (err: any, ok: Replies.Empty) => void): boolean;
+        sendToQueue(queue: string, content: Buffer, options?: Options.Publish, callback?: (err: any, ok: Replies.Empty) => void): boolean;
+
+        waitForConfirms(callback?: (err: any) => void): void;
+    }
+
+    function connect(callback: (err: any, connection: Connection) => void): void;
+    function connect(url: string, callback: (err: any, connection: Connection) => void): void;
+    function connect(url: string, socketOptions: any, callback: (err: any, connection: Connection) => void): void;
+}

analytics-node/analytics-node-tests.ts

@@ -0,0 +1,91 @@
+/// <reference path="./analytics-node.d.ts" />
+
+var analytics: AnalyticsNode.Analytics;
+import Analytics = require("analytics-node");
+
+function testConfig(): void {
+  analytics = new Analytics('YOUR_WRITE_KEY', {
+    flushAt: 20,
+    flushAfter: 10000
+  });
+}
+
+function testIdentify(): void {
+  analytics.identify({
+    userId: '019mr8mf4r',
+    traits: {
+      name: 'Michael Bolton',
+      email: 'mbolton@initech.com',
+      plan: 'Enterprise',
+      friends: 42
+    }
+  });
+}
+
+function testTrack(): void {
+  analytics.track({
+    userId: '019mr8mf4r',
+    event: 'Purchased an Item',
+    properties: {
+      revenue: 39.95,
+      shippingMethod: '2-day'
+    }
+  });
+}
+
+function testPage(): void {
+  analytics.page({
+    userId: '019mr8mf4r',
+    category: 'Docs',
+    name: 'Node.js Library',
+    properties: {
+      url: 'https://segment.com/docs/libraries/node',
+      path: '/docs/libraries/node/',
+      title: 'Node.js Library - Segment',
+      referrer: 'https://github.com/segmentio/analytics-node'
+    }
+  });
+}
+
+function testAlias(): void {
+  // the anonymous user does actions ...
+  analytics.track({ userId: 'anonymous_user', event: 'Anonymous Event' })
+  // the anonymous user signs up and is aliased
+  analytics.alias({ previousId: 'anonymous_user', userId: 'identified@gmail.com' })
+  // the identified user is identified
+  analytics.identify({ userId: 'identified@gmail.com', traits: { plan: 'Free' } })
+  // the identified user does actions ...
+  analytics.track({ userId: 'identified@gmail.com', event: 'Identified Action' })
+}
+
+function testGroup(): void {
+  analytics.group({
+    userId: '019mr8mf4r',
+    groupId: '56',
+    traits: {
+      name: 'Initech',
+      description: 'Accounting Software'
+    }
+  });
+}
+
+function testIntegrations(): void {
+  analytics.track({
+    event: 'Upgraded Membershipt',
+    userId: '97234974',
+    integrations: {
+      'All': false,
+      'Vero': true,
+      'Google Analytics': false
+    }
+  });
+}
+
+function testFlush(): void {
+  analytics.flush();
+  analytics.flush(function(err, batch) {
+    if (err) { alert("Oh nos!"); }
+    else { console.log(batch.batch[0].type); }
+  });
+}
+

analytics-node/analytics-node.d.ts

@@ -0,0 +1,83 @@
+// Type definitions for Segment's analytics.js for Node.js
+// Project: https://segment.com/docs/libraries/node/
+// Definitions by: Andrew Fong <https://github.com/fongandrew>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module AnalyticsNode {
+
+  interface Integrations {
+    [index: string]: boolean;
+  }
+
+  export class Analytics {
+    constructor(writeKey: string, opts?: {
+      flushAt?: number,
+      flushAfter?: number
+    });
+
+    /* The identify method lets you tie a user to their actions and record
+       traits about them. */
+    identify(message: {
+      userId: string | number;
+      traits?: Object;
+      timestamp?: Date;
+      context?: Object;
+      integrations?: Integrations;
+    }): Analytics;
+
+    /* The track method lets you record the actions your users perform. */
+    track(message: {
+      userId: string | number;
+      event: string;
+      properties?: Object;
+      timestamp?: Date;
+      context?: Object;
+      integrations?: Integrations;
+    }): Analytics;
+
+    /* The page method lets you record page views on your website, along with
+       optional extra information about the page being viewed. */
+    page(message: {
+      userId: string | number;
+      category?: string;
+      name?: string;
+      properties?: Object;
+      timestamp?: Date;
+      context?: Object;
+      integrations?: Integrations;
+    }): Analytics;
+
+    /* alias is how you associate one identity with another. */
+    alias(message: {
+      previousId: string | number;
+      userId: string | number;
+      integrations?: Integrations;
+    }): Analytics;
+
+    /* Group calls can be used to associate individual users with shared
+       accounts or companies. */
+    group(message: {
+      userId: string | number;
+      groupId: string | number;
+      traits?: Object;
+      context?: Object;
+      timestamp?: Date;
+      anonymous_id?: string | number;
+      integrations?: Integrations;
+    }): Analytics;
+
+    /* Flush batched calls to make sure nothing is left in the queue */
+    flush(fn?: (err: Error, batch: {
+      batch: Array<{
+        type: string;
+      }>;
+      messageId: string;
+      sentAt: Date;
+      timestamp: Date;
+    }) => void): Analytics;
+  }
+}
+
+declare module "analytics-node" {
+  export = AnalyticsNode.Analytics;
+}

angular-dialog-service/angular-dialog-service-tests.ts

@@ -0,0 +1,16 @@
+/// <reference path="angular-dialog-service.d.ts" />
+
+
+var options : angular.dialogservice.IDialogOptions = {};
+options.animation = true;
+options.backdrop = true;
+options.keyboard = true;
+options.backdropClass = "some-css-class";
+options.windowClass = "some-css-class";
+options.size = 'md';
+
+var dialogs : angular.dialogservice.IDialogService;
+dialogs.error('Error','An unknown error occurred preventing the completion of the requested action.');
+dialogs.wait('Creating User','Please wait while we attempt to create user "Michael Conroy."<br><br>This should only take a moment.',50);
+dialogs.notify('Something Happened','Something happened at this point in the application that I wish to let you know about');
+dialogs.create('url/to/a/template','ctrlrToUse',{},{});

angular-dialog-service/angular-dialog-service.d.ts

@@ -0,0 +1,82 @@
+// Type definitions for Angular Dialog Service 5.2.8
+// Project: https://github.com/m-e-conroy/angular-dialog-service
+// Definitions by: William Comartin <https://github.com/wcomartin>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts"/>
+/// <reference path="../angular-ui-bootstrap/angular-ui-bootstrap.d.ts"/>
+
+declare module angular.dialogservice {
+
+  interface IDialogOptions {
+    /**
+     * Set to false to disable animations on new modal/backdrop. Does not toggle animations for modals/backdrops that are already displayed.
+     *
+     * @default false
+     */
+    animation?: boolean;
+
+    /**
+     * controls the presence of a backdrop
+     * Allowed values:
+     *   - true (default)
+     *   - false (no backdrop)
+     *   - 'static' backdrop is present but modal window is not closed when clicking outside of the modal window
+     *
+     * @default true
+     */
+    backdrop?: boolean | string;
+
+    /**
+     * indicates whether the dialog should be closable by hitting the ESC key
+     *
+     * @default true
+     */
+    keyboard?: boolean;
+
+    /**
+     * additional CSS class(es) to be added to a modal backdrop template
+     *
+     * @default 'dialogs-backdrop-default'
+     */
+    backdropClass?: string;
+
+    /**
+     * additional CSS class(es) to be added to a modal window template
+     *
+     * @default 'dialogs-default'
+     */
+    windowClass?: string;
+
+    /**
+     * Optional suffix of modal window class. The value used is appended to the `modal-` class, i.e. a value of `sm` gives `modal-sm`.
+     *
+     * @default 'lg'
+     */
+    size?: string;
+  }
+
+  interface IDialogService {
+    /**
+     * Opens a new error modal instance.
+     */
+    error(header: string, msg: string, opts?: IDialogOptions): ng.ui.bootstrap.IModalServiceInstance
+    /**
+     * Opens a new wait modal instance.
+     */
+    wait(header: string, msg: string, progress: number, opts?: IDialogOptions): ng.ui.bootstrap.IModalServiceInstance
+    /**
+     * Opens a new notify modal instance.
+     */
+    notify(header: string, msg: string, opts?: IDialogOptions): ng.ui.bootstrap.IModalServiceInstance
+    /**
+     * Opens a new confirm modal instance.
+     */
+    confirm(header: string, msg: string, opts?: IDialogOptions): ng.ui.bootstrap.IModalServiceInstance
+    /**
+     * Opens a new custom modal instance.
+     */
+    create(url: string, ctrlr: string, data: any, opts?: IDialogOptions): ng.ui.bootstrap.IModalServiceInstance
+  }
+
+}

angular-dynamic-locale/angular-dynamic-locale.d.ts

@@ -5,6 +5,11 @@
 
 /// <reference path="../angularjs/angular.d.ts" />
 
+declare module "angular-dynamic-locale" {
+	import ng = angular.dynamicLocale;
+	export = ng;
+}
+
 declare module angular.dynamicLocale {
 
 	interface tmhDynamicLocaleService {

angular-formly/angular-formly-tests.ts

@@ -20,11 +20,23 @@ class FormConfig {
 			name: 'customInput',
 			extends: 'input'
 		});
+
+		formlyConfig.disableWarnings = true;		
+		formlyConfig.templateManipulators = undefined;
+
+		formlyConfig.extras.apiCheckInstance = null;
+		formlyConfig.extras.defaultHideDirective = 'ng-if';
+		formlyConfig.extras.disableNgModelAttrsManipulator = true;
+		formlyConfig.extras.errorExistsAndShouldBeVisibleExpression = angular.noop;
+		formlyConfig.extras.explicitAsync = true;		
+		formlyConfig.extras.fieldTransform = angular.noop;
+		formlyConfig.extras.getFieldId = angular.noop;
+		formlyConfig.extras.ngModelAttrsManipulatorPreferUnbound = true;
 	}
 }
 
 class AppController {
-	fields: AngularFormly.IFieldConfigurationObject[];
+	fields: AngularFormly.IFieldArray;
 	constructor() {
 		var vm = this;
 		vm.fields = [
@@ -99,6 +111,21 @@ class AppController {
 				templateOptions: {
 					label: 'no wrapper here...'
 				}
+			},
+			{
+				//From http://angular-formly.com/#/example/other/nested-formly-forms
+				key: 'address',
+				wrapper: 'panel',
+				templateOptions: { label: 'Address' },
+				fieldGroup: [{
+				  key: 'town',
+				  type: 'input',
+				  templateOptions: {
+					required: true,
+					type: 'text',
+					label: 'Town'
+				  }
+				}]
 			}
 		]
 	}

angular-formly/angular-formly.d.ts

@@ -1,7 +1,7 @@
-// Type definitions for angular-formly 6.18.0
+// Type definitions for angular-formly 7.2.3
 // Project: https://github.com/formly-js/angular-formly
 // Definitions by: Scott Hatcher <https://github.com/scatcher>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference path="../angularjs/angular.d.ts" />
 
@@ -9,20 +9,30 @@ declare module 'AngularFormly' {
 	export = AngularFormly;
 }
 
+declare module 'angular-formly' {
+	var angularFormlyDefaultExport: string;
+	export = angularFormlyDefaultExport;
+}
+
 declare module AngularFormly {
 
+    interface IFieldArray extends Array<IFieldConfigurationObject | IFieldGroup> {
+
+    }
 
 	interface IFieldGroup {
 		data?: Object;
 		className?: string;
-		elementAttributes?: { [key: string]: string };
-		fieldGroup: IFieldConfigurationObject[];
+		elementAttributes?: string;
+        fieldGroup?: IFieldArray;
 		form?: Object;
 		hide?: boolean;
-		hideExpression?: string | IExpresssionFunction;
+		hideExpression?: string | IExpressionFunction;
 		key?: string | number;
 		model?: string | Object;
-		options?: IFormOptionsAPI
+        options?: IFormOptionsAPI;
+        templateOptions?: ITemplateOptions;
+        wrapper?: string | string[];
 	}
 
 
@@ -41,7 +51,7 @@ declare module AngularFormly {
 	/**
 	 * see http://docs.angular-formly.com/docs/formly-expressions#expressionproperties-validators--messages
 	 */
-	interface IExpresssionFunction {
+	interface IExpressionFunction {
 		($viewValue: any, $modelValue: any, scope: ITemplateScope): any;
 	}
 
@@ -65,6 +75,11 @@ declare module AngularFormly {
 		postWrapper?: ITemplateManipulator[];
 	}
 
+	interface ISelectOption {
+		name: string;
+		value?: string;
+		group?: string;
+	}
 
 	/**
 	 * see http://docs.angular-formly.com/docs/ngmodelattrstemplatemanipulator
@@ -99,6 +114,12 @@ declare module AngularFormly {
 		description?: string;
 		[key: string]: any;
 
+		// types for select/radio fields
+		options?: Array<ISelectOption>;
+		groupProp?: string;  // default: group
+		valueProp?: string;  // default: value
+		labelProp?: string;  // default: name
+
 	}
 
 
@@ -106,8 +127,8 @@ declare module AngularFormly {
 	 * see http://docs.angular-formly.com/docs/field-configuration-object#validators-object
 	 */
 	interface IValidator {
-		expression: string | IExpresssionFunction;
-		message?: string | IExpresssionFunction;
+		expression: string | IExpressionFunction;
+		message?: string | IExpressionFunction;
 	}
 
 
@@ -138,8 +159,8 @@ declare module AngularFormly {
 		 * see http://angular-formly.com/#/example/other/unique-value-async-validation
 		 */
 		asyncValidators?: {
-			[key: string]: string | IExpresssionFunction | IValidator;
-		}
+			[key: string]: string | IExpressionFunction | IValidator;
+		};
 
 		/**
 		 * This is a great way to add custom behavior to a specific field. It is injectable with the $scope of the
@@ -188,8 +209,8 @@ declare module AngularFormly {
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#expressionproperties-object
 		 */
 		expressionProperties?: {
-			[key: string]: string | IExpresssionFunction | IValidator;
-		}
+			[key: string]: string | IExpressionFunction | IValidator;
+		};
 
 
 		/**
@@ -198,7 +219,7 @@ declare module AngularFormly {
 		 *
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#hide-boolean
 		 */
-		hide?: boolean
+		hide?: boolean;
 
 
 		/**
@@ -208,7 +229,7 @@ declare module AngularFormly {
 		 *
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#hideexpression-string--function
 		 */
-		hideExpression?: string | IExpresssionFunction;
+		hideExpression?: string | IExpressionFunction;
 
 
 		/**
@@ -297,6 +318,18 @@ declare module AngularFormly {
 			bound?: any;
 			expression?: any;
 			value?: any;
+			[key: string]: any;
+		};
+
+
+		/**
+		 * This allows you to place attributes with string values on the ng-model element.
+		 * Easy to use alternative to ngModelAttrs option.
+		 *
+		 * see http://docs.angular-formly.com/docs/field-configuration-object#ngmodelelattrs-object
+		 */
+		ngModelElAttrs?: {
+			[key: string]: string;
 		};
 
 
@@ -388,7 +421,7 @@ declare module AngularFormly {
 			 * like in this example.
 			 */
 			messages?: {
-				[key: string]: IExpresssionFunction | string;
+				[key: string]: IExpressionFunction | string;
 			}
 
 
@@ -399,7 +432,7 @@ declare module AngularFormly {
 			 */
 			show?: boolean;
 
-		}
+		};
 
 
 		/**
@@ -412,8 +445,8 @@ declare module AngularFormly {
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#validators-object
 		 */
 		validators?: {
-			[key: string]: string | IExpresssionFunction | IValidator;
-		}
+			[key: string]: string | IExpressionFunction | IValidator;
+		};
 
 
 		/**
@@ -525,10 +558,24 @@ declare module AngularFormly {
 		validateOptions?: Function;
 	}
 
+	interface IFormlyConfigExtras {
+		disableNgModelAttrsManipulator: boolean;
+		apiCheckInstance: any;
+		ngModelAttrsManipulatorPreferUnbound: boolean;
+		removeChromeAutoComplete: boolean;
+		defaultHideDirective: string;
+		errorExistsAndShouldBeVisibleExpression: any;
+		getFieldId: Function;
+		fieldTransform: Function;
+		explicitAsync: boolean;
+	}
+
 	interface IFormlyConfig {
+		disableWarnings: boolean;
+		extras: IFormlyConfigExtras;
 		setType(typeOptions: ITypeOptions): void;
 		setWrapper(wrapperOptions: IWrapperOptions): void;
-
+		templateManipulators: ITemplateManipulators;
 	}
 
 	interface ITemplateScopeOptions {
@@ -545,7 +592,7 @@ declare module AngularFormly {
 		//Shortcut to options.formControl
 		fc: ng.IFormController | ng.IFormController[];
 		//all the fields for the form
-		fields: IFieldConfigurationObject[];
+		fields: IFieldArray;
 		//the form controller the field is in
 		form: any;
 		//The object passed as options.formState to the formly-form directive. Use this to share state between fields.
@@ -571,4 +618,4 @@ declare module AngularFormly {
 		messages: { [key: string]: ($viewValue: any, $modelValue: any, scope: ITemplateScope) => string };
 	}
 
-}
+}

angular-gettext/angular-gettext-tests.ts

@@ -1,61 +1,61 @@
-/// <reference path="angular-gettext.d.ts" />
-
-module angular_gettext_tests {
-  
-
-  // Configuring angular-gettext
-  // https://angular-gettext.rocketeer.be/dev-guide/configure/
-  //Setting the language
-  angular.module('myApp').run(function (gettextCatalog: angular.gettext.gettextCatalog) {
-    gettextCatalog.setCurrentLanguage('nl');
-  });
-
-  //Highlighting untranslated strings
-  angular.module('myApp').run(function (gettextCatalog: angular.gettext.gettextCatalog) {
-    gettextCatalog.debug = true;
-  });
-
-  
-  // Marking strings in JavaScript code as translatable. 
-  // https://angular-gettext.rocketeer.be/dev-guide/annotate-js/  
-  angular.module("myApp").controller("helloController", function (gettext: angular.gettext.gettextFunction) {
-    var myString = gettext("Hello");
-  });  
-
-  //Translating directly in JavaScript.
-  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
-    var translated: string = gettextCatalog.getString("Hello");
-  });
-
-  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
-    var myString2: string = gettextCatalog.getPlural(3, "Bird", "Birds");
-  });
-
-  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
-    var translated: string = gettextCatalog.getString("Hello {{name}}", { name: "Ruben" });
-  });
-
-  // Setting strings manually
-  // https://angular-gettext.rocketeer.be/dev-guide/manual-setstrings/
-
-  angular.module("myApp").run(function (gettextCatalog: angular.gettext.gettextCatalog) {
-    // Load the strings automatically during initialization.
-    gettextCatalog.setStrings("nl", {
-      "Hello": "Hallo",
-      "One boat": ["Een boot", "{{$count}} boats"]
-    });
-  });
-
-
-  interface helloControllerScope extends ng.IScope {
-    switchLanguage: (lang: string) => void;
-  }
-  // Lazy-loading languages
-  // https://angular-gettext.rocketeer.be/dev-guide/lazy-loading/
-  angular.module("myApp").controller("helloController", function ($scope: helloControllerScope, gettextCatalog: angular.gettext.gettextCatalog) {
-    $scope.switchLanguage = function (lang: string) {
-      gettextCatalog.setCurrentLanguage(lang);
-      gettextCatalog.loadRemote("/languages/" + lang + ".json");
-    };
-  });
+/// <reference path="angular-gettext.d.ts" />
+
+module angular_gettext_tests {
+  
+
+  // Configuring angular-gettext
+  // https://angular-gettext.rocketeer.be/dev-guide/configure/
+  //Setting the language
+  angular.module('myApp').run(function (gettextCatalog: angular.gettext.gettextCatalog) {
+    gettextCatalog.setCurrentLanguage('nl');
+  });
+
+  //Highlighting untranslated strings
+  angular.module('myApp').run(function (gettextCatalog: angular.gettext.gettextCatalog) {
+    gettextCatalog.debug = true;
+  });
+
+  
+  // Marking strings in JavaScript code as translatable. 
+  // https://angular-gettext.rocketeer.be/dev-guide/annotate-js/  
+  angular.module("myApp").controller("helloController", function (gettext: angular.gettext.gettextFunction) {
+    var myString = gettext("Hello");
+  });  
+
+  //Translating directly in JavaScript.
+  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
+    var translated: string = gettextCatalog.getString("Hello");
+  });
+
+  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
+    var myString2: string = gettextCatalog.getPlural(3, "Bird", "Birds");
+  });
+
+  angular.module("myApp").controller("helloController", function (gettextCatalog: angular.gettext.gettextCatalog) {
+    var translated: string = gettextCatalog.getString("Hello {{name}}", { name: "Ruben" });
+  });
+
+  // Setting strings manually
+  // https://angular-gettext.rocketeer.be/dev-guide/manual-setstrings/
+
+  angular.module("myApp").run(function (gettextCatalog: angular.gettext.gettextCatalog) {
+    // Load the strings automatically during initialization.
+    gettextCatalog.setStrings("nl", {
+      "Hello": "Hallo",
+      "One boat": ["Een boot", "{{$count}} boats"]
+    });
+  });
+
+
+  interface helloControllerScope extends ng.IScope {
+    switchLanguage: (lang: string) => void;
+  }
+  // Lazy-loading languages
+  // https://angular-gettext.rocketeer.be/dev-guide/lazy-loading/
+  angular.module("myApp").controller("helloController", function ($scope: helloControllerScope, gettextCatalog: angular.gettext.gettextCatalog) {
+    $scope.switchLanguage = function (lang: string) {
+      gettextCatalog.setCurrentLanguage(lang);
+      gettextCatalog.loadRemote("/languages/" + lang + ".json");
+    };
+  });
 }

angular-gettext/angular-gettext.d.ts

@@ -1,73 +1,73 @@
-// Type definitions for angular-gettext v2.1.0
-// Project: https://angular-gettext.rocketeer.be/
-// Definitions by: Ákos Lukács <https://github.com/AkosLukacs>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-/// <reference path="../angularjs/angular.d.ts" />
-
-declare module angular.gettext {
-  interface gettextCatalog {
-
-    //////////////
-    /// Fields ///
-    //////////////
-
-    /** (default: false): Whether or not to prefix untranslated strings with [MISSING]: or a custom prefix. */
-    debug: boolean;
-    /** (default: [MISSING]:): Custom prefix for untranslated strings. */
-    debugPrefix: string;
-    /** (default: false): Whether or not to wrap all processed text with markers.Example output: [Welcome] */
-    showTranslatedMarkers: boolean;
-    /** (default: [): Custom prefix to mark strings that have been run through angular-gettext. */
-    translatedMarkerPrefix: string;
-    /** (default: ]): Custom suffix to mark strings that have been run through angular-gettext. */
-    translatedMarkerSuffix: string;
-    /** An object of loaded translation strings.Shouldn't be used directly. */
-    strings: {};
-    /** The default language, in which you're application is written. This defaults to English and it's generally a bad idea to use anything else: if your language has different pluralization rules you'll end up with incorrect translations. Deprecated 
-     * @deprecreated
-     */
-    baseLanguage: string;
-
-
-    ///////////////
-    /// Methods ///
-    ///////////////
-
-    /** Sets the current language and makes sure that all translations get updated correctly. */
-    setCurrentLanguage(lang: string): void;
-
-    /** Returns the current language. */
-    getCurrentLanguage(): string;
-
-    /** Processes an object of string definitions. More details https://angular-gettext.rocketeer.be/dev-guide/manual-setstrings/
-     * @param language A language code.
-     * @param strings A dictionary of strings. The format of this dictionary is:
-     *                   - Keys: Singular English strings (as defined in the source files)
-     *                   - Values: Either a single string for signular-only strings or an array of plural forms.
-     */
-    setStrings(language: string, strings: { [key: string]: string|string[] }): void;
-
-    /** Get the correct pluralized (but untranslated) string for the value of n. */
-    getStringForm(string: string, n: number): string;
-
-    /** Translate a string with the given context. Uses Angular.JS interpolation, so something like this will do what you expect: 
-     * var hello = gettextCatalog.getString("Hello {{name}}!", { name: "Ruben" });
-     * // var hello will be "Hallo Ruben!" in Dutch.
-     * The context parameter is optional: pass null (or don't pass anything) if you're not using it: this skips interpolation and is a lot faster.
-     */
-    getString(string: string, context?: any): string;
-
-    /** Translate a plural string with the given context. */
-    getPlural(n: number, string: string, stringPlural: string, context?: any): string;
-
-    /** Load a set of translation strings from a given URL.This should be a JSON catalog generated with grunt-angular-gettext. More details https://angular-gettext.rocketeer.be/dev-guide/lazy-loading/ */
-    loadRemote(url: string): ng.IHttpPromise<any>;
-  }
-
-  /** If you have text that should be translated in your JavaScript code, wrap it with a call to a function named gettext. This module provides an injectable function to do so */
-  interface gettextFunction {
-    (dummyString: string): string;
-  }
-}
-
+// Type definitions for angular-gettext v2.1.0
+// Project: https://angular-gettext.rocketeer.be/
+// Definitions by: Ákos Lukács <https://github.com/AkosLukacs>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module angular.gettext {
+  interface gettextCatalog {
+
+    //////////////
+    /// Fields ///
+    //////////////
+
+    /** (default: false): Whether or not to prefix untranslated strings with [MISSING]: or a custom prefix. */
+    debug: boolean;
+    /** (default: [MISSING]:): Custom prefix for untranslated strings. */
+    debugPrefix: string;
+    /** (default: false): Whether or not to wrap all processed text with markers.Example output: [Welcome] */
+    showTranslatedMarkers: boolean;
+    /** (default: [): Custom prefix to mark strings that have been run through angular-gettext. */
+    translatedMarkerPrefix: string;
+    /** (default: ]): Custom suffix to mark strings that have been run through angular-gettext. */
+    translatedMarkerSuffix: string;
+    /** An object of loaded translation strings.Shouldn't be used directly. */
+    strings: {};
+    /** The default language, in which you're application is written. This defaults to English and it's generally a bad idea to use anything else: if your language has different pluralization rules you'll end up with incorrect translations. Deprecated 
+     * @deprecreated
+     */
+    baseLanguage: string;
+
+
+    ///////////////
+    /// Methods ///
+    ///////////////
+
+    /** Sets the current language and makes sure that all translations get updated correctly. */
+    setCurrentLanguage(lang: string): void;
+
+    /** Returns the current language. */
+    getCurrentLanguage(): string;
+
+    /** Processes an object of string definitions. More details https://angular-gettext.rocketeer.be/dev-guide/manual-setstrings/
+     * @param language A language code.
+     * @param strings A dictionary of strings. The format of this dictionary is:
+     *                   - Keys: Singular English strings (as defined in the source files)
+     *                   - Values: Either a single string for signular-only strings or an array of plural forms.
+     */
+    setStrings(language: string, strings: { [key: string]: string|string[] }): void;
+
+    /** Get the correct pluralized (but untranslated) string for the value of n. */
+    getStringForm(string: string, n: number): string;
+
+    /** Translate a string with the given context. Uses Angular.JS interpolation, so something like this will do what you expect: 
+     * var hello = gettextCatalog.getString("Hello {{name}}!", { name: "Ruben" });
+     * // var hello will be "Hallo Ruben!" in Dutch.
+     * The context parameter is optional: pass null (or don't pass anything) if you're not using it: this skips interpolation and is a lot faster.
+     */
+    getString(string: string, context?: any): string;
+
+    /** Translate a plural string with the given context. */
+    getPlural(n: number, string: string, stringPlural: string, context?: any): string;
+
+    /** Load a set of translation strings from a given URL.This should be a JSON catalog generated with grunt-angular-gettext. More details https://angular-gettext.rocketeer.be/dev-guide/lazy-loading/ */
+    loadRemote(url: string): ng.IHttpPromise<any>;
+  }
+
+  /** If you have text that should be translated in your JavaScript code, wrap it with a call to a function named gettext. This module provides an injectable function to do so */
+  interface gettextFunction {
+    (dummyString: string): string;
+  }
+}
+

angular-google-analytics/angular-google-analytics-tests.ts

@@ -0,0 +1,56 @@
+/// <reference path="angular-google-analytics.d.ts" />
+
+function ConfigurationMethodChaining(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider
+        .logAllCalls(true)
+        .startOffline(true)
+        .useECommerce(true, true);
+}
+
+function EnableECommerce(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.useECommerce(true, false);
+    AnalyticsProvider.useECommerce(true, true);
+    AnalyticsProvider.setCurrency("CDN");
+}
+
+function SetGoogleAnalyticsAccounts(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.setAccount("UA-XXXXX-xx");
+    AnalyticsProvider.setAccount([
+        { tracker: "UA-12345-12", name: "tracker1" },
+        { tracker: "UA-12345-34", name: "tracker2" }
+    ]);
+}
+
+function UseClassicAnalytics(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.useAnalytics(false);
+}
+
+function UseDisplayFeatures(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.useDisplayFeatures(true);
+}
+
+function UseEnhancedLinkAttribution(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.useEnhancedLinkAttribution(true);
+}
+
+function UseCrossDomainLinking(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.useCrossDomainLinker(true);
+    AnalyticsProvider.setCrossLinkDomains(["domain-1.com", "domain-2.com"]);
+}
+
+function SetCookieConfiguration(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.setCookieConfig({
+        cookieDomain: "foo.example.com",
+        cookieName: "myNewName",
+        cookieExpires: 20000
+    });
+}
+
+function SetRouteTrackingBehaviors(AnalyticsProvider: angular.google.analytics.AnalyticsProvider) {
+    AnalyticsProvider.trackPages(true);
+    AnalyticsProvider.trackUrlParams(true);
+    AnalyticsProvider.ignoreFirstPageLoad(true);
+    AnalyticsProvider.trackPrefix("my-application");
+    AnalyticsProvider.setPageEvent("$stateChangeSuccess");
+    AnalyticsProvider.setRemoveRegExp(/\/\d+?$/);
+}

angular-google-analytics/angular-google-analytics.d.ts

@@ -0,0 +1,173 @@
+// Type definitions for angular-google-analytics v1.1.0
+// Project: https://github.com/revolunet/angular-google-analytics
+// Definitions by: Cyril Schumacher <https://github.com/cyrilschumacher>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module angular.google.analytics {
+    /**
+     * @summary Interface for {@link AnalysticsProvider}.
+     * @interface
+     */
+    interface AnalyticsProvider {
+        /**
+         * @summary Use Delay Script Tag Insertion.
+         * @param {boolean} val If true, the delay script tag is inserted.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        delayScriptTag(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Activates the test mode.
+         */
+        enterTestMode(): void;
+
+        /**
+         * @summary Gets the global cookie configuration.
+         * @return {Object} The global cookie configuration.
+         */
+        getCookieConfig(): Object;
+
+        /**
+         * @summary Ignore first page view.
+         * @param {boolean} val If true, the first page view is ignored.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        ignoreFirstPageLoad(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Enable Service Logging.
+         * @param {boolean} val If true, log all outbound calls to an in-memory array accessible.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        logAllCalls(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Set Google Analytics Accounts.
+         * @param {Object} tracker The account identifier(s).
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setAccount(tracker: string|Object|Array<Object>): AnalyticsProvider;
+
+        /**
+         * @summary Set Cookie Configuration.
+         * @param {Object} config The custom cookie parameters.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         * @deprecated
+         */
+        setCookieConfig(config: Object): AnalyticsProvider;
+
+        /**
+         * @summary Set cross-linked domains.
+         * @param {Array<string>} domains The domains.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setCrossLinkDomains(domains: Array<string>): AnalyticsProvider;
+
+        /**
+         * @summary Set currency.
+         * @param {string} currencyCode The currency code.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setCurrency(currencyCode: string): AnalyticsProvider;
+
+        /**
+         * @summary Set Domain Name.
+         * @param {string} domain The domain name.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setDomainName(domain: string): AnalyticsProvider;
+
+        /**
+         * @summary Enable Experiment (universal analytics only).
+         * @param {string} id The experiment identifier.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setExperimentId(id: string): AnalyticsProvider;
+
+        /**
+         * @summary Support Hybrid Mobile Applications.
+         * @param {boolean} val If true, each account object will disable protocol checking and all injected scripts will use the HTTPS protocol.
+         */
+        setHybridMobileSupport(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Set the default page event name.
+         * @param {string} name The default page event name.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        setPageEvent(name: string): AnalyticsProvider;
+
+        /**
+         * @summary Sets the regex to scrub location before sending to analytics.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         * @param {RegExp} regex The regex.
+         */
+        setRemoveRegExp(regex: RegExp): AnalyticsProvider;
+
+        /**
+         * @summary Starts the offline mode.
+         * @param {boolean} val If true, the offline mode is started.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        startOffline(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Track all routes.
+         * @param {boolean} val If true, all routes are tracked.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        trackPages(doTrack: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Sets the URL prefix.
+         * @param {string} prefix The URL prefix.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        trackPrefix(prefix: string): AnalyticsProvider;
+
+        /**
+         * @summary Track all URL query parameters.
+         * @param {boolean} val If true, all URL query parameters are tracked.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        trackUrlParams(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Use Classic Analytics.
+         * @param {boolean} val If true, use classic analytics.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        useAnalytics(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Use Cross Domain Linking.
+         * @param {boolean} val If true, the cross-linked domains are registered with Google Analytics.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        useCrossDomainLinker(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Use Display Features.
+         * @param {boolean} val If true, the display features module is loaded with Google Analytics.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        useDisplayFeatures(val: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Enable enhanced e-commerce module.
+         * @param {boolean} val If true, the enhanced e-commerce module is enabled.
+         * @param {boolean} enhanced If true, the "ec.js" file is used, otherwises, the "ecommerce.js" is used.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        useECommerce(val: boolean, enhanced: boolean): AnalyticsProvider;
+
+        /**
+         * @summary Use Enhanced Link Attribution.
+         * @param {boolean} val If true, the enhanced link attribution module is loaded with Google Analytics.
+         * @return {angular.google.analytics.IAnalyticsProvider} The object instance.
+         */
+        useEnhancedLinkAttribution(val: boolean): AnalyticsProvider;
+    }
+}

angular-growl-v2/angular-growl-v2-test.ts

@@ -1,53 +0,0 @@
-/// <reference path="angular-growl-v2.d.ts" />
-
-var app = angular.module("ag", ["pascalprecht.translate", "$httpProvider"]);
-
-app.config((growlProvider:angular.growl.IGrowlProvider, $httpProvider:angular.IHttpProvider) => {
-    var ttl:angular.growl.IGrowlTTLConfig = {
-        success: 5000,
-        error: 4000
-    };
-
-    growlProvider.globalTimeToLive(ttl);
-    growlProvider.globalTimeToLive(5000);
-    growlProvider.globalDisableCloseButton(true);
-    growlProvider.globalDisableIcons(true);
-    growlProvider.globalReversedOrder(false);
-    growlProvider.globalDisableCountDown(true);
-    growlProvider.messageVariableKey("someKey");
-    growlProvider.globalInlineMessages(false);
-    growlProvider.globalPosition("top-center");
-    growlProvider.messagesKey("someKey");
-    growlProvider.messageTextKey("someKey");
-    growlProvider.messageTitleKey("someKey");
-    growlProvider.messageSeverityKey("someKey");
-    growlProvider.onlyUniqueMessages(false);
-
-    $httpProvider.interceptors.push(growlProvider.serverMessagesInterceptor);
-});
-
-app.controller("Ctrl", ($scope:angular.IScope, growl:angular.growl.IGrowlService) => {
-    var config:angular.growl.IGrowlMessageConfig = {
-        ttl: 5000,
-        disableCountDown: true,
-        disableCloseButton: true
-    };
-
-    var message = "Some message";
-
-    growl.warning(message);
-    growl.warning(message, config);
-    growl.error(message);
-    growl.error(message, config);
-    growl.info(message);
-    growl.info(message, config);
-    growl.success(message);
-    growl.success(message, config);
-    growl.general(message);
-    growl.general(message, config);
-    growl.general(message, config, "error");
-    growl.onlyUnique();
-    growl.reverseOrder();
-    growl.inlineMessages();
-    growl.position();
-});

angular-growl-v2/angular-growl-v2-tests.ts

@@ -0,0 +1,65 @@
+/// <reference path="angular-growl-v2.d.ts" />
+
+var app = angular.module("ag", ["pascalprecht.translate", "$httpProvider"]);
+
+app.config((growlProvider:angular.growl.IGrowlProvider, $httpProvider:angular.IHttpProvider) => {
+    var ttl:angular.growl.IGrowlTTLConfig = {
+        success: 5000,
+        error: 4000
+    };
+
+    growlProvider.globalTimeToLive(ttl)
+        .globalTimeToLive(5000)
+        .globalDisableCloseButton(true)
+        .globalDisableIcons(true)
+        .globalReversedOrder(false)
+        .globalDisableCountDown(true)
+        .messageVariableKey("someKey")
+        .globalInlineMessages(false)
+        .globalPosition("top-center")
+        .messagesKey("someKey")
+        .messageTextKey("someKey")
+        .messageTitleKey("someKey")
+        .messageSeverityKey("someKey")
+        .onlyUniqueMessages(false);
+
+    $httpProvider.interceptors.push(growlProvider.serverMessagesInterceptor);
+});
+
+app.controller("Ctrl", ($scope:angular.IScope,
+                        growl:angular.growl.IGrowlService,
+                        growlMessages:angular.growl.IGrowlMessagesService) => {
+    var config:angular.growl.IGrowlMessageConfig = {
+        ttl: 5000,
+        disableCountDown: true,
+        disableCloseButton: true
+    };
+
+    var message = "Some message";
+
+    growl.warning(message);
+    growl.warning(message, config);
+    growl.error(message);
+    growl.error(message, config);
+    growl.info(message);
+    growl.info(message, config);
+    growl.success(message);
+    growl.success(message, config);
+    growl.general(message);
+    growl.general(message, config);
+    growl.general(message, config, "error");
+    growl.onlyUnique();
+    growl.reverseOrder();
+    growl.inlineMessages();
+    growl.position();
+
+    growlMessages.initDirective(1, 10);
+    var messages:angular.growl.IGrowlMessage[] = growlMessages.getAllMessages(2);
+    growlMessages.destroyAllMessages(0);
+    growlMessages.addMessage(messages[0]);
+    growlMessages.deleteMessage(messages[1]);
+    
+    var testMessage = growl.warning(message);
+    testMessage.setText("Some other message");
+    testMessage.destroy();
+});

angular-growl-v2/angular-growl-v2.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angular Growl 2 v.0.7.3
+// Type definitions for Angular Growl 2 v.0.7.5
 // Project: http://janstevens.github.io/angular-growl-2
 // Definitions by: Tadeusz Hucal <https://github.com/mkp05>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -26,9 +26,12 @@ declare module angular.growl {
         disableCountDown?: boolean;
         disableIcons?: boolean;
         disableCloseButton?: boolean;
-        referenceId?: number;
         onclose?: Function;
         onopen?: Function;
+        position?: string;
+        referenceId?: number;
+        translateMessage?: boolean;
+        variables?: { [variable: string]: any; };
     }
 
     /**
@@ -36,6 +39,16 @@ declare module angular.growl {
      */
     interface IGrowlMessage extends IGrowlMessageConfig {
         text: string;
+        
+        /**
+         * Destroy the message.
+         */
+        destroy(): void;
+        /**
+         * Update the message body.
+         * @param newText new message body
+         */
+        setText(newText: string): void;
     }
 
     /**
@@ -51,73 +64,73 @@ declare module angular.growl {
          * Set default TTL settings.
          * @param ttl configuration of TTL for different type of message
          */
-        globalTimeToLive(ttl: IGrowlTTLConfig): void;
+        globalTimeToLive(ttl: IGrowlTTLConfig): IGrowlProvider;
         /**
          * Set default TTL settings.
          * @param ttl ttl in milliseconds
          */
-        globalTimeToLive(ttl: number): void;
+        globalTimeToLive(ttl: number): IGrowlProvider;
         /**
          * Set default setting for disabling close button.
          * @param disableCloseButton
          */
-        globalDisableCloseButton(disableCloseButton: boolean): void;
+        globalDisableCloseButton(disableCloseButton: boolean): IGrowlProvider;
         /**
          * Set default setting for disabling icons.
          * @param disableIcons
          */
-        globalDisableIcons(disableIcons: boolean): void;
+        globalDisableIcons(disableIcons: boolean): IGrowlProvider;
         /**
          * Set reversing order of displaying new messages.
          * @param reverseOrder
          */
-        globalReversedOrder(reverseOrder: boolean): void
+        globalReversedOrder(reverseOrder: boolean): IGrowlProvider;
         /**
          * Set default setting for displaying message disappear countdown.
          * @param disableCountDown
          */
-        globalDisableCountDown(disableCountDown: boolean): void;
+        globalDisableCountDown(disableCountDown: boolean): IGrowlProvider;
         /**
          * Set default allowance for inline messages.
          * @param inline
          */
-        globalInlineMessages(inline: boolean): void;
+        globalInlineMessages(inline: boolean): IGrowlProvider;
         /**
          * Set default message position.
          * @param position
          */
-        globalPosition(position: string): void;
+        globalPosition(position: string): IGrowlProvider;
         /**
          * Enable/disable displaying only unique messages.
          * @param onlyUniqueMessages
          */
-        onlyUniqueMessages(onlyUniqueMessages: boolean): void;
+        onlyUniqueMessages(onlyUniqueMessages: boolean): IGrowlProvider;
 
         /**
          * Set key where messages are stored (for http interceptor).
          * @param messageVariableKey
          */
-        messagesKey(messageKey: string): void;
+        messagesKey(messageKey: string): IGrowlProvider;
         /**
          * Set key where message text is stored (for http interceptor).
          * @param messageVariableKey
          */
-        messageTextKey(messageTextKey: string): void;
+        messageTextKey(messageTextKey: string): IGrowlProvider;
         /**
          * Set key where title of message is stored (for http interceptor).
          * @param messageVariableKey
          */
-        messageTitleKey(messageTitleKey: string): void;
+        messageTitleKey(messageTitleKey: string): IGrowlProvider;
         /**
          * Set key where severity of message is stored (for http interceptor).
          * @param messageVariableKey
          */
-        messageSeverityKey(messageSeverityKey: string): void;
+        messageSeverityKey(messageSeverityKey: string): IGrowlProvider;
         /**
          * Set key where variables for message are stored (for http interceptor).
          * @param messageVariableKey
          */
-        messageVariableKey(messageVariableKey: string): void;
+        messageVariableKey(messageVariableKey: string): IGrowlProvider;
     }
 
     /**
@@ -208,4 +221,39 @@ declare module angular.growl {
          */
         position(): string;
     }
+
+    /**
+     * GrowlMessages service.
+     */
+    interface IGrowlMessagesService {
+        /**
+         * Initialize a directive
+         * We look at the preloaded directive and use this else we
+         * create a new blank object
+         * @param referenceId
+         * @param limitMessages
+         */
+        initDirective(referenceId: number, limitMessages: number): angular.IDirective;
+
+        /**
+         * Get current messages
+         */
+        getAllMessages(referenceId?: number): IGrowlMessage[];
+
+        /**
+         * Destroy all messages
+         */
+        destroyAllMessages(referenceId?: number): void;
+
+        /**
+         * Add a message
+         */
+        addMessage(message: IGrowlMessage): IGrowlMessage;
+
+        /**
+         * Delete a message
+         */
+        deleteMessage(message: IGrowlMessage): void;
+
+    }
 }

angular-httpi/angular-httpi-tests.ts

@@ -0,0 +1,64 @@
+/// <reference path="./angular-httpi.d.ts" />
+
+(function() {
+    'use strict';
+    var app = angular.module("Demo", ["httpi"]);
+    // -------------------------------------------------- //
+    // -------------------------------------------------- //
+    // I control the main demo.
+    app.controller(
+        "DemoController",
+        function($scope: ng.IScope, httpi: Httpi.HttpiFactory) {
+
+            console.warn("None of the API endpoints exist - they will all throw 404.");
+            // NOTE: The (.|.) notation will be stripped out automatically; it's only
+            // here to improve readability of the "happy paths" for interpolation
+            // labels. The following urls are pre-processed to be identical:
+            // --
+            // api/friends/( :listCommand | :id/:itemCommand )
+            // api/friends/:listCommand:id/:itemCommand
+            var resource = httpi.resource("api/friends/( :listCommand | :id/:itemCommand )");
+            // Clear list of friends - matching listCommand.
+            resource.post({
+                data: {
+                    listCommand: "reset"
+                }
+            });
+            // Create a new friend - no matching URL parameters.
+            resource.post({
+                data: {
+                    name: "Tricia"
+                }
+            });
+            // Get a given friend - ID matching.
+            resource.get({
+                data: {
+                    id: 4
+                }
+            });
+            // Make best friend - ID, itemCommand matching.
+            resource.post({
+                data: {
+                    id: 4,
+                    itemCommand: "make-best-friend"
+                }
+            });
+            // Get gets friends - no matching URL parameters.
+            resource.get({
+                params: {
+                    limit: "besties"
+                }
+            });
+            // Get a friend as a JSONP request.
+            // --
+            // NOTE: The "resource" will auto-inject the "JSON_CALLBACK" marker that
+            // AngularJS will automatically replace with an internal callback name.
+            resource.jsonp({
+                data: {
+                    id: 43
+                }
+            });
+        }
+    );
+
+})();

angular-httpi/angular-httpi.d.ts

@@ -0,0 +1,42 @@
+// Type definitions for angular-httpi
+// Project: https://github.com/bennadel/httpi
+// Definitions by: Andrew Camilleri <https://github.com/Kukks>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module Httpi {
+    export interface HttpiPayload extends ng.IRequestShortcutConfig {
+        method?: string;
+        url?: string;
+        params?: {};
+        data?: {};
+        keepTrailingSlash?: boolean;
+    }
+
+    export interface HttpiFactory {
+
+        (config: HttpiPayload): ng.IHttpPromise<{}>;
+
+        resource(url: string): HttpiResource;
+    }
+
+    export class HttpiResource {
+
+        constructor(http: ng.IHttpService, url: string);
+
+        delete<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        get<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        head<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        jsonp<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        post<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        put<T>(config: HttpiPayload): ng.IHttpPromise<T>;
+
+        setKeepTrailingSlash(newKeepTrailingSlash: boolean): HttpiResource;
+    }
+}

angular-jwt/angular-jwt.d.ts

@@ -25,6 +25,6 @@ declare module angular.jwt {
     }
 
     interface IJwtInterceptor {
-        tokenGetter(): string;
+        tokenGetter(...params : any[]): string;
     }
 }

angular-loading-bar/angular-loading-bar-tests.ts

@@ -0,0 +1,23 @@
+/// <reference path="angular-loading-bar.d.ts" />
+
+var app = angular.module('testModule', ['angular-loading-bar']);
+
+class TestController {
+
+	constructor($http: ng.IHttpService) {
+
+		$http.get("http://xyz.com", { ignoreLoadingBar: true })
+
+	}
+
+}
+
+app.controller('TestController', TestController);
+
+var barConfig: angular.loadingBar.ILoadingBarProvider[] = [];
+barConfig.push({
+    includeSpinner: true,
+    includeBar: true,
+    spinnerTemplate: 'template',
+    latencyThreshold: 100
+});

angular-loading-bar/angular-loading-bar.d.ts

@@ -0,0 +1,43 @@
+// Type definitions for angular-loading-bar
+// Project: https://github.com/chieffancypants/angular-loading-bar
+// Definitions by: Stephen Lautier <https://github.com/stephenlautier>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+
+declare module angular {
+
+	interface IRequestShortcutConfig {
+		/**
+		 * Indicates that the loading bar should be hidden.
+		 */
+		ignoreLoadingBar?: boolean;
+	}
+}
+
+declare module angular.loadingBar {
+	
+	interface ILoadingBarProvider{
+		/**
+		* Turn the spinner on or off
+		*/
+		includeSpinner?: boolean;
+
+		/**
+		* Turn the loading bar on or off
+		*/
+		includeBar?: boolean;
+
+		/**
+		* HTML template
+		*/
+		spinnerTemplate?: string;
+
+		/**
+		* Latency Threshold
+		*/
+		latencyThreshold?: number;
+	}
+
+}

angular-locker/angular-locker-tests.ts

@@ -0,0 +1,133 @@
+/// <reference path='../angularjs/angular.d.ts' />
+/// <reference path='angular-locker.d.ts' />
+
+angular
+.module('angular-locker-tests', ['angular-locker'])
+.config(['lockerProvider', function config(lockerProvider: angular.locker.ILockerProvider) {
+    let lockerSettings: angular.locker.ILockerSettings = {
+        driver: 'session',
+        namespace: 'myApp',
+        separator: '.',
+        eventsEnabled: true,
+        extend: <any>{}
+    };
+
+    lockerProvider.defaults(lockerSettings);
+}])
+.controller('LockerController', ['$scope', 'locker', function ($scope: angular.IScope, locker: angular.locker.ILockerService) {
+    locker.put('someKey', 'someVal');
+
+    // put an item into session storage
+    locker.driver('session').put('sessionKey', ['some', 'session', 'data']);
+
+    // add an item within a different namespace
+    locker.namespace('otherNamespace').put('foo', 'bar');
+
+    locker.put('someString', 'anyDataType');
+    locker.put('someObject', { foo: 'I will be serialized', bar: 'pretty cool eh' });
+    locker.put('someArray', ['foo', 'bar', 'baz']);
+    // etc
+
+    //Inserts specified key and return value of function
+    locker.put('someKey', function() {
+        var obj = { foo: 'bar', bar: 'baz' };
+        // some other logic
+        return obj;
+    });
+
+    locker.put('someKey', ['foo', 'bar']);
+
+    //The current value will be passed into the function so you can perform logic on the current value, before returning it. e.g.
+    locker.put('someKey', function(current: any) {
+        current.push('baz');
+
+        return current;
+    });
+
+    locker.get('someKey'); // = ['foo', 'bar', 'baz']
+
+    // given locker.get('foo') is not defined
+    locker.put('foo', function (current: any) {
+        // current will equal 'bar'
+    }, 'bar');
+
+    //This will add each key/value pair as a separate item in storage
+    locker.put({
+        someKey: 'johndoe',
+        anotherKey: ['some', 'random', 'array'],
+        boolKey: true
+    });
+
+    locker.add('someKey', 'someVal'); // true or false - whether the item was added or not
+
+    // locker.put('fooArray', ['bar', 'baz', 'bob']);
+
+    locker.get('fooArray'); // ['bar', 'baz', 'bob']
+
+    locker.get('keyDoesNotExist', 'a default value'); // 'a default value'
+
+    locker.get(['someKey', 'anotherKey', 'foo']);
+    /* will return something like...
+    {
+        someKey: 'someValue',
+        anotherKey: true,
+        foo: 'bar'
+    }*/
+
+    // locker.put('someKey', { foo: 'bar', baz: 'bob' });
+
+    locker.pull('someKey', 'defaultVal'); // { foo: 'bar', baz: 'bob' }
+
+    // then...
+
+    locker.get('someKey', 'defaultVal'); // 'defaultVal'
+
+    locker.all();
+    // or
+    locker.namespace('somethingElse').all();
+
+    locker.count();
+    // or
+    locker.namespace('somethingElse').count();
+
+    locker.has('someKey'); // true or false
+
+    // or
+    locker.namespace('foo').has('bar');
+
+    // e.g.
+    if (locker.has('user.authToken') ) {
+        // we're logged in
+    } else {
+        // go to login page or something
+    }
+
+    locker.forget('keyToRemove');
+    // or
+    locker.driver('session').forget('sessionKey');
+    // etc..
+
+    locker.forget(['keyToRemove', 'anotherKeyToRemove', 'something', 'else']);
+
+    locker.clean();
+    // or
+    locker.namespace('someOtherNamespace').clean();
+
+    locker.empty();
+
+    locker.bind($scope, 'foo');
+    $scope['foo'] = ['bar', 'baz'];
+    locker.get('foo'); // = ['bar', 'baz']
+
+    locker.bind($scope, 'foo', 'someDefault');
+    $scope['foo']; // = 'someDefault'
+    locker.get('foo'); // = 'someDefault'
+
+    locker.unbind($scope, 'foo');
+    $scope['foo']; // = undefined
+    locker.get('foo'); // = undefined
+
+    if (! locker.supported()) {
+        // load a polyfill?
+    }
+}]);

angular-locker/angular-locker.d.ts

@@ -0,0 +1,170 @@
+// Type definitions for Angular Locker v2.0.3
+// Project: https://github.com/tymondesigns/angular-locker
+// Definitions by: Niko Kovačič <https://github.com/nkovacic>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module "angular-locker" {
+    var _: string;
+    export = _;
+}
+
+declare module angular.locker {
+    interface ILockerServicePutFunction {
+        (current: any): any
+    }
+
+    interface ILockerService {
+        /**
+        * Add an item to storage if it doesn't already exist
+        *
+        * @param  {String}  key    The key to add
+        * @param  {Mixed}  value  The value to add
+        */
+        add(key: string, value: any): boolean;
+        /**
+        * Return all items in storage within the current namespace/driver
+        *
+        */
+        all(): any;
+        /**
+        * Remove all items set within the current namespace/driver
+        */
+        clean(): ILockerService;
+        /**
+        * Get the total number of items within the current namespace
+        */
+        count(): number;
+        /**
+        * Retrieve the specified item from storage
+        *
+        * @param  {String|Array}  key  The key to get
+        * @param  {Mixed}         def  The default value if it does not exist
+        */
+        get(key: string | Array<string>, defaultValue?: any): any;
+        /**
+        * Determine whether the item exists in storage
+        *
+        * @param  {String|Function}  key  -  The key to remove
+        */
+        has(key: string): boolean
+        /**
+        * Get the storage keys as an array
+        */
+        keys(): Array<string>;
+        /**
+        * Add a new item to storage (even if it already exists)
+        *
+        * @param  {Object}  keyValuePairs    Key value object
+        */
+        put(keyValuePairs: Object): ILockerService | boolean;
+        /**
+        * Add a new item to storage (even if it already exists)
+        *
+        * @param  {Mixed}  putFunction    The default to pass to function if doesn't already exist
+        */
+        put(putFunction: Function): ILockerService | boolean;
+        /**
+        * Add a new item to storage (even if it already exists)
+        *
+        * @param  {Mixed}  key    The key to add
+        * @param  {Mixed}  value  The value to add     
+        */
+        put(key: string, value: any): ILockerService | boolean;
+        /**
+        * Add a new item to storage (even if it already exists)
+        *
+        * @param  {Mixed}  key    The key to add
+        * @param  {Mixed}  putFunction    The default to pass to function if doesn't already exist
+        * @param  {Mixed}  value  The value to add     
+        */
+        put(key: string, putFunction: ILockerServicePutFunction, value: any): ILockerService | boolean;
+        /**
+        * Remove specified item(s) from storage
+        *
+        * @param  {String}  key  The key to remove
+        */
+        forget(key: string): ILockerService;
+        /**
+        * Remove specified item(s) from storage
+        *
+        * @param  {Array}  keys  The array of keys to remove
+        *
+        */
+        forget(keys: Array<string>): ILockerService;
+        /**
+        * Retrieve the specified item from storage and then remove it
+        *
+        * @param  {String|Array}  key  The key to pull from storage
+        * @param  {Mixed}   def  The default value if it does not exist
+        */
+        pull(key: string | Array<string>, defaultValue?: any): any;
+        /**
+        * Bind a storage key to a $scope property
+        *
+        * @param  {Object}  $scope  The angular $scope object
+        * @param  {String}  key     The key in storage to bind to
+        * @param  {Mixed}   def     The default value to initially bind
+        */
+        bind(scope: IScope, property: string, defaultPropertyValue?: any): ILockerService;
+        /**
+        * Set the storage driver on a new instance to enable overriding defaults
+        *
+        * @param  {String}  driver  The driver to switch to
+        */
+        driver(localStorageType: string): ILockerService;
+        /**
+        * Empty the current storage driver completely. careful now.
+        */
+        empty(): ILockerService;
+        /**
+        * Get the currently set namespace
+        */
+        getNamespace(): string;
+        /**
+        * Get a new instance of Locker
+        *
+        * @param  {Object}  options  The config options to instantiate with
+        */
+        instance(lockerSettings: ILockerSettings): ILockerService;
+        /**
+        * Set the namespace on a new instance to enable overriding defaults
+        *
+        * @param  {String}  namespace  The namespace to switch to
+        */
+        'namespace'(name: string): ILockerService;
+        /**
+        * Check browser support
+        *
+        * @see github.com/Modernizr/Modernizr/blob/master/feature-detects/storage/localstorage.js#L38-L47
+        *
+        * @param  {String}  driver  The driver to check support with
+        */
+        supported(): boolean;
+        /**
+        * Unbind a storage key from a $scope property
+        *
+        * @param  {Object}  $scope  The angular $scope object
+        * @param  {String}  key     The key to remove from bindings
+        */
+        unbind(scope: IScope, property: string): ILockerService;
+    }
+
+    interface ILockerSettings {
+        driver?: string;
+        'namespace'?: string | boolean;
+        separator?: string;
+        eventsEnabled?: boolean;
+        extend?: Object;
+    }
+
+    interface ILockerProvider extends angular.IServiceProvider {
+        /**
+        * Allow the defaults to be specified via the `lockerProvider`
+        *
+        * @param {ILockerSettings}  lockerSettings  The defaults to override
+        */
+        defaults(lockerSettings: ILockerSettings): void;
+    }
+}

angular-material/angular-material-0.8.3.d.ts

@@ -59,7 +59,7 @@ declare module angular.material {
         show(dialog: MDDialogOptions|MDPresetDialog<any>): angular.IPromise<any>;
         confirm(): MDConfirmDialog;
         alert(): MDAlertDialog;
-        hide(response?: any): void;
+        hide(response?: any): angular.IPromise<any>;
         cancel(response?: any): void;
     }
 

angular-material/angular-material-0.9.0.d.ts

@@ -64,7 +64,7 @@ declare module angular.material {
         show(dialog: MDDialogOptions|MDAlertDialog|MDConfirmDialog): angular.IPromise<any>;
         confirm(): MDConfirmDialog;
         alert(): MDAlertDialog;
-        hide(response?: any): void;
+        hide(response?: any): angular.IPromise<any>;
         cancel(response?: any): void;
     }
 

angular-material/angular-material-tests.ts

@@ -44,10 +44,16 @@ myApp.controller('DialogController', ($scope: ng.IScope, $mdDialog: ng.material.
         });
     };
     $scope['alertDialog'] = () => {
-        $mdDialog.show($mdDialog.alert().content('Alert!'));
+        $mdDialog.show($mdDialog.alert().textContent('Alert!'));
+    };
+    $scope['alertDialog'] = () => {
+        $mdDialog.show($mdDialog.alert().htmlContent('<span>Alert!</span>'));
     };
     $scope['confirmDialog'] = () => {
-        $mdDialog.show($mdDialog.confirm().content('Confirm!'));
+        $mdDialog.show($mdDialog.confirm().textContent('Confirm!'));
+    };
+    $scope['confirmDialog'] = () => {
+        $mdDialog.show($mdDialog.confirm().htmlContent('<span>Confirm!</span>'));
     };
     $scope['hideDialog'] = $mdDialog.hide.bind($mdDialog, 'hide');
     $scope['cancelDialog'] = $mdDialog.cancel.bind($mdDialog, 'cancel');
@@ -90,5 +96,5 @@ myApp.controller('SidenavController', ($scope: ng.IScope, $mdSidenav: ng.materia
 });
 
 myApp.controller('ToastController', ($scope: ng.IScope, $mdToast: ng.material.IToastService) => {
-    $scope['openToast'] = () => $mdToast.show($mdToast.simple().content('Hello!'));
-});
+    $scope['openToast'] = () => $mdToast.show($mdToast.simple().textContent('Hello!'));
+});

angular-material/angular-material.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angular Material 0.10.1-rc1+ (angular.material module)
+// Type definitions for Angular Material 1.0.0-rc5+ (angular.material module)
 // Project: https://github.com/angular/material
 // Definitions by: Matt Traynham <https://github.com/mtraynham>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -16,6 +16,7 @@ declare module angular.material {
         targetEvent?: MouseEvent;
         resolve?: {[index: string]: angular.IPromise<any>}
         controllerAs?: string;
+        bindToController?: boolean;
         parent?: string|Element|JQuery; // default: root node
         disableParentScroll?: boolean; // default: true
     }
@@ -28,7 +29,8 @@ declare module angular.material {
 
     interface IPresetDialog<T> {
         title(title: string): T;
-        content(content: string): T;
+        textContent(textContent: string): T;
+        htmlContent(htmlContent: string): T;
         ok(ok: string): T;
         theme(theme: string): T;
         templateUrl(templateUrl?: string): T;
@@ -75,6 +77,7 @@ declare module angular.material {
         resolve?: {[index: string]: angular.IPromise<any>}
         controllerAs?: string;
         parent?: string|Element|JQuery; // default: root node
+        fullscreen?: boolean;
         onComplete?: Function;
     }
 
@@ -82,7 +85,7 @@ declare module angular.material {
         show(dialog: IDialogOptions|IAlertDialog|IConfirmDialog): angular.IPromise<any>;
         confirm(): IConfirmDialog;
         alert(): IAlertDialog;
-        hide(response?: any): void;
+        hide(response?: any): angular.IPromise<any>;
         cancel(response?: any): void;
     }
 
@@ -115,7 +118,7 @@ declare module angular.material {
     }
 
     interface IToastPreset<T> {
-        content(content: string): T;
+        textContent(content: string): T;
         action(action: string): T;
         highlightAction(highlightAction: boolean): T;
         capsule(capsule: boolean): T;
@@ -221,4 +224,19 @@ declare module angular.material {
         setDefaultTheme(theme: string): void;
         alwaysWatchTheme(alwaysWatch: boolean): void;
     }
+    
+    interface IDateLocaleProvider {
+        months: string[];
+        shortMonths: string[];
+        days: string[];
+        shortDays: string[];
+        dates: string[];
+        firstDayOfWeek: number;
+        parseDate(dateString: string): Date;
+        formatDate(date: Date): string;
+        monthHeaderFormatter(date: Date): string;
+        weekNumberFormatter(weekNumber: number): string;
+        msgCalendar: string;
+        msgOpenCalendar: string;
+    }
 }

angular-meteor/angular-meteor.d.ts

@@ -39,6 +39,28 @@ declare module angular.meteor {
          * @return The promise solved successfully when subscription is ready. The success promise holds the subscription handle.
          */
         subscribe(name: string, ...publisherArguments: any[]): angular.IPromise<Meteor.SubscriptionHandle>;
+
+        /**
+         * The helpers method is part of the ReactiveContext, and available on every context and $scope.
+         * These method are defined as Object, where each key is the name of the variable that will be available on the context we run, and each value is a function with a return value.
+         * Under the hood, each helper starts a new Tracker.autorun. When its reactive dependencies change, the helper is rerun.
+         * To trigger a rerun every time an specific Angular variable change, use getReactively](/api/1.3.1/get-reactively) to make your Angular variable reactive inside the helper its used in.
+         * Each helper function should return a MongoDB Cursor and the helpers will expose it as a normal array to the context.
+         *
+         * @param definitions - Object containing `name` => `function` definition, where each name is a string and each function is the helper function. Should return a [MongoDB Cursor](http://docs.meteor.com/#/full/mongo_cursor)
+         * @return This method returns this, which the the reactive context, in order to provide the ability to chain the logic.
+         */
+        helpers(definitions : { [helperName : string] : () => Mongo.Cursor<any> }): IScope;
+
+        /**
+         * This method is a wrapper of Tracker.autorun and shares exactly the same API.
+         * The autorun method is part of the ReactiveContext, and available on every context and $scope.
+         * The argument of this method is a callback, which will be called each time Autorun will be used.
+         * The Autorun will stop automatically when when it's context ($scope) is destroyed.
+         * 
+         * @param runFunc - The function to run. It receives one argument: the Computation object that will be returned.
+         */
+        autorun(runFunc : () => void) : Tracker.Computation;
     }
     
     /**

angular-modal/angular-modal-tests.ts

@@ -0,0 +1,104 @@
+/// <reference path="../jquery/jquery.d.ts" />
+/// <reference path="../angularjs/angular.d.ts" />
+/// <reference path="angular-modal.d.ts" />
+
+var btfModal: angularModal.AngularModalFactory;
+
+// Using template URL
+function withTemplateUrl() {
+    btfModal({
+        controller: 'SomeController',
+        controllerAs: 'vm',
+        templateUrl: 'some-template.html'
+    });
+}
+
+// Using template
+function withTemplate() {
+    btfModal({
+        controller: 'SomeController',
+        controllerAs: 'vm',
+        template: '<div></div>'
+    });
+}
+
+// Using controller function
+function withControllerAsFunction() {
+    btfModal({
+        controller: function () {},
+        template: '<div></div>'
+    })
+}
+
+// Using constructor function
+function withControllerClass() {
+    class TestController {
+        constructor(dependency1:any, dependency2:any) {}
+    }
+    btfModal({
+        controller: TestController,
+        template: '<div></div>'
+    });
+}
+
+// With container as selector
+function withContainerAsString() {
+    btfModal({
+        template: '<div></div>',
+        container: '.container'
+    });
+}
+
+// With container as jQuery element
+function withContainerAsJquery() {
+    var container: JQuery = $('body');
+    btfModal({
+        template: '<div></div>',
+        container: container
+    });
+}
+
+// With container as DOM Element
+function withContainerAsDom() {
+    var container: Element = document.getElementById('container');
+    btfModal({
+        template: '<div></div>',
+        container: container
+    });
+}
+
+// With container as DOM Element Array
+function withContainerAsDomArray() {
+    var container: Element[] = [document.getElementById('container'), document.getElementById('container2')];
+    btfModal({
+        template: '<div></div>',
+        container: container
+    });
+}
+
+// With container as function
+function withContainerAsFunction() {
+    btfModal({
+        template: '<div></div>',
+        container: function() {}
+    });
+}
+
+// With container as array
+function withContainerAsArray() {
+    btfModal({
+        template: '<div></div>',
+        container: ['1', 2]
+    });
+}
+
+// Calling return values
+function callingValues() {
+    var modal: angularModal.AngularModal = btfModal({
+        template: '<div></div>'
+    });
+    modal.activate().then(() => {}, () => {});
+    modal.deactivate().then(() => {}, () => {});
+    var isActive: boolean = modal.active();
+}
+

angular-modal/angular-modal.d.ts

@@ -0,0 +1,38 @@
+// Type definitions for angular-modal 0.5.0
+// Project: https://github.com/btford/angular-modal
+// Definitions by: Paul Lessing <https://github.com/paullessing>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+/// <reference path="../jquery/jquery.d.ts" />
+
+declare module angularModal {
+
+    type AngularModalControllerDefinition = (new (...args: any[]) => any) | Function | string; // Possible arguments to IControllerService
+
+    type AngularModalJQuerySelector = string | Element | Element[] | JQuery | Function | any[] | {}; // Possible arguments to IAugmentedJQueryStatic
+
+    interface AngularModalSettings {
+        controller?: AngularModalControllerDefinition;
+        controllerAs?: string;
+        container?: AngularModalJQuerySelector;
+    }
+
+    export interface AngularModalSettingsWithTemplate extends AngularModalSettings {
+        template: any;
+    }
+
+    export interface AngularModalSettingsWithTemplateUrl extends AngularModalSettings {
+        templateUrl: string;
+    }
+
+    export interface AngularModal {
+        activate(): angular.IPromise<void>;
+        deactivate(): angular.IPromise<void>;
+        active(): boolean;
+    }
+
+    export interface AngularModalFactory {
+        (settings: AngularModalSettingsWithTemplate | AngularModalSettingsWithTemplateUrl): AngularModal;
+    }
+}

angular-notify/angular-notify.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for angular-notify 2.0.2
+// Type definitions for angular-notify 2.5.0
 // Project: https://github.com/cgross/angular-notify
 // Definitions by: Suwato <https://github.com/Suwato/DefinitelyTyped>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -51,6 +51,11 @@ declare module angular.cgNotify {
              * Optional. Currently center and right are the only acceptable values.
              */
             position? : string;
+            
+            /**
+             * Optional. The duration (in milliseconds) of the message. A duration of 0 will prevent the message from closing automatically.
+             */
+            duration? : number;
 
             /**
              * Optional. Element that contains each notification. Defaults to document.body.
@@ -94,6 +99,11 @@ declare module angular.cgNotify {
              * The default element that contains each notification. Defaults to document.body.
              */
             container? : any;
+            
+            /**
+             * The maximum number of total notifications that can be visible at one time. Older notifications will be closed when the maximum is reached.
+             */
+            maximumOpen? : number;
         }):void;
 
         /**

angular-odata-resources/angular-odata-resources.d.ts

@@ -19,6 +19,7 @@ declare module OData {
             url?: string;
             method?: string;
         };
+        isodatav4?: boolean;
     }
 
 

angular-protractor/angular-protractor-tests.ts

@@ -196,6 +196,27 @@ function TestWebDriverUntilModule() {
     conditionWebElements = protractor.until.elementsLocated(by.className('class'));
 }
 
+function TestWebDriverExpectedConditionsModule() {
+    var conditionB: protractor.until.Condition<boolean>;
+    var el: protractor.ElementFinder = element(by.id('id'));
+
+    conditionB = protractor.ExpectedConditions.alertIsPresent();
+    conditionB = protractor.ExpectedConditions.elementToBeClickable(el);
+    conditionB = protractor.ExpectedConditions.textToBePresentInElement(el, 'text');
+    conditionB = protractor.ExpectedConditions.textToBePresentInElementValue(el, 'text');
+    conditionB = protractor.ExpectedConditions.titleContains('text');
+    conditionB = protractor.ExpectedConditions.titleIs('text');
+    conditionB = protractor.ExpectedConditions.presenceOf(el);
+    conditionB = protractor.ExpectedConditions.stalenessOf(el);
+    conditionB = protractor.ExpectedConditions.visibilityOf(el);
+    conditionB = protractor.ExpectedConditions.invisibilityOf(el);
+    conditionB = protractor.ExpectedConditions.elementToBeSelected(el);
+
+    conditionB = protractor.ExpectedConditions.not(protractor.ExpectedConditions.alertIsPresent());
+    conditionB = protractor.ExpectedConditions.and(protractor.ExpectedConditions.alertIsPresent(), protractor.ExpectedConditions.elementToBeClickable(el));
+    conditionB = protractor.ExpectedConditions.or(protractor.ExpectedConditions.alertIsPresent(), protractor.ExpectedConditions.elementToBeClickable(el));
+}
+
 function TestProtractor() {
     var ptor: protractor.Protractor;
     var driver: webdriver.WebDriver = new webdriver.Builder().

angular-protractor/angular-protractor.d.ts

@@ -501,6 +501,145 @@ declare module protractor {
         function titleMatches(regex: RegExp): webdriver.until.Condition<boolean>;
     }
 
+    module ExpectedConditions {
+        /**
+         * Negates the result of a promise.
+         *
+         * @param {webdriver.until.Condition<boolean>} expectedCondition
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns the negated value.
+         */
+        function not<T>(expectedCondition: webdriver.until.Condition<T>): webdriver.until.Condition<T>;
+
+        /**
+         * Chain a number of expected conditions using logical_and, short circuiting at the
+         * first expected condition that evaluates to false.
+         *
+         * @param {...webdriver.until.Condition<boolean>[]} fns An array of expected conditions to 'and' together.
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise which evaluates
+         * to the result of the logical and.
+         */
+        function and<T>(...fns: webdriver.until.Condition<T>[]): webdriver.until.Condition<T>;
+
+        /**
+         * Chain a number of expected conditions using logical_or, short circuiting at the
+         * first expected condition that evaluates to true.
+         *
+         * @param {...webdriver.until.Condition<boolean>[]} fns An array of expected conditions to 'or' together.
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise which
+         * evaluates to the result of the logical or.
+         */
+        function or<T>(...fns: webdriver.until.Condition<T>[]): webdriver.until.Condition<T>;
+
+        /**
+         * Expect an alert to be present.
+         *
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether an alert is present.
+         */
+        function alertIsPresent<T>(): webdriver.until.Condition<T>;
+
+        /**
+         * An Expectation for checking an element is visible and enabled such that you can click it.
+         *
+         * @param {ElementFinder} element The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the element is clickable.
+         */
+        function elementToBeClickable<T>(element: ElementFinder): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking if the given text is present in the element.
+         * Returns false if the elementFinder does not find an element.
+         *
+         * @param {ElementFinder} element The element to check
+         * @param {string} text The text to verify against
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the text is present in the element.
+         */
+        function textToBePresentInElement<T>(element: ElementFinder, text: string): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking if the given text is present in the element’s value.
+         * Returns false if the elementFinder does not find an element.
+         *
+         * @param {ElementFinder} element The element to check
+         * @param {string} text The text to verify against
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the text is present in the element's value.
+         */
+        function textToBePresentInElementValue<T>(
+          element: ElementFinder, text: string
+        ): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking that the title contains a case-sensitive substring.
+         *
+         * @param {string} title The fragment of title expected
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the title contains the string.
+         */
+        function titleContains<T>(title: string): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking the title of a page.
+         *
+         * @param {string} title The expected title, which must be an exact match.
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the title equals the string.
+         */
+        function titleIs<T>(title: string): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking that an element is present on the DOM of a page. This does not necessarily
+         * mean that the element is visible. This is the opposite of 'stalenessOf'.
+         *
+         * @param {ElementFinder} elementFinder The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise
+         * representing whether the element is present.
+         */
+        function presenceOf<T>(element: ElementFinder): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking that an element is not attached to the DOM of a page.
+         * This is the opposite of 'presenceOf'.
+         *
+         * @param {ElementFinder} elementFinder The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the element is stale.
+         */
+        function stalenessOf<T>(element: ElementFinder): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking that an element is present on the DOM of a page and visible.
+         * Visibility means that the element is not only displayed but also has a height and width that is
+         * greater than 0. This is the opposite of 'invisibilityOf'.
+         *
+         * @param {ElementFinder} elementFinder The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the element is visible.
+         */
+        function visibilityOf<T>(element: ElementFinder): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking that an element is present on the DOM of a page. This does not necessarily
+         * mean that the element is visible. This is the opposite of 'stalenessOf'.
+         *
+         * @param {ElementFinder} elementFinder The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the element is invisible.
+         */
+        function invisibilityOf<T>(element: ElementFinder): webdriver.until.Condition<T>;
+
+        /**
+         * An expectation for checking the selection is selected.
+         *
+         * @param {ElementFinder} elementFinder The element to check
+         * @return {!webdriver.until.Condition<boolean>} An expected condition that returns a promise representing
+         * whether the element is selected.
+         */
+        function elementToBeSelected<T>(element: ElementFinder): webdriver.until.Condition<T>;
+    }
+
     //endregion
 
     /**
@@ -1667,6 +1806,16 @@ declare module protractor {
         * @return {Protractor} a protractor instance.
         */
         forkNewDriverInstance(opt_useSameUrl?: boolean, opt_copyMockModules?: boolean): Protractor;
+
+        /**
+        * Get the processed configuration object that is currently being run. This will contain
+        * the specs and capabilities properties of the current runner instance.
+        *
+        * Set by the runner.
+        *
+        * @return {webdriver.promise.Promise<any>} A promise which resolves to the capabilities object.
+        */
+        getProcessedConfig(): webdriver.promise.Promise<any>;
     }
 
     /**

angular-strap/angular-strap-tests.ts

@@ -0,0 +1,378 @@
+/// <reference path="../angularjs/angular.d.ts"/>
+/// <reference path="./angular-strap.d.ts"/>
+
+module angularStrapTests {
+
+    import ngStrap = mgcrea.ngStrap;
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Modal
+    ///////////////////////////////////////////////////////////////////////////
+
+    module modalTests {
+
+        interface IDemoCtrlScope extends ngStrap.modal.IModalScope {
+            showModal: () => void;
+        }
+
+        angular.module('demoApp')
+            .config($modalConfig)
+            .controller('demoCtrl', demoCtrl);
+
+        function demoCtrl($scope: IDemoCtrlScope,
+                            $modal: ngStrap.modal.IModalService): void {
+
+            var myModalOptions: ngStrap.modal.IModalOptions = {};
+            myModalOptions.title = 'My Title';
+            myModalOptions.content = 'Hello Modal<br />This is a multiline message!';
+            myModalOptions.show = true;
+
+            var myModal = $modal(myModalOptions);
+
+            var myOtherModalOptions: ngStrap.modal.IModalOptions = {};
+            myOtherModalOptions.scope = $scope;
+            myOtherModalOptions.template = 'modal/docs/modal.demo.tpl.html';
+            myOtherModalOptions.show = false;
+
+            var myOtherModal = $modal(myOtherModalOptions);
+
+            $scope.showModal = (): void => {
+                myOtherModal.$promise.then(myOtherModal.show);
+            };
+        }
+
+        function $modalConfig($modalProvider: ngStrap.modal.IModalProvider): void {
+            var defaults: ngStrap.modal.IModalOptions = {
+                animation: 'am-flip-x'
+            }
+            angular.extend($modalProvider.defaults, defaults);
+        }
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Aside
+    ///////////////////////////////////////////////////////////////////////////
+
+    module asideTests {
+
+        angular.module('demoApp')
+            .config($asideConfig)
+            .controller('demoCtrl', demoCtrl);
+
+        function demoCtrl($scope: ngStrap.aside.IAsideScope,
+                            $aside: ngStrap.aside.IAsideService): void {
+
+            var myAsideOptions: ngStrap.aside.IAsideOptions = {};
+            myAsideOptions.title = 'My Title';
+            myAsideOptions.content = 'My content';
+            myAsideOptions.show = true;
+
+            var myAside = $aside(myAsideOptions);
+
+            var myOtherAsideOptions: ngStrap.aside.IAsideOptions = {};
+            myOtherAsideOptions.scope = $scope;
+            myOtherAsideOptions.template = 'aside/docs/aside.demo.tpl.html';
+
+            var myOtherAside = $aside();
+
+            myOtherAside.$promise.then(() => {
+                myOtherAside.show();
+            });
+        }
+
+        function $asideConfig($asideProvider: ngStrap.aside.IAsideProvider): void {
+            var defaults: ngStrap.aside.IAsideOptions = {};
+            defaults.animation = 'am-fadeAndSlideLeft';
+            defaults.placement = 'left';
+                
+            angular.extend($asideProvider.defaults, defaults);
+        }
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Alert
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module alertTests {
+
+        angular.module('demoApp')
+            .config($alertConfig)
+            .controller('demoCtrl', demoCtrl);
+
+        function demoCtrl($scope: ngStrap.alert.IAlertScope,
+                            $alert: ngStrap.alert.IAlertService): void {
+
+            var options: ngStrap.alert.IAlertOptions = {};
+            options.title = 'Holy guacamole!';
+            options.content = 'Best check yo self, you\'re not looking too good.';
+            options.placement = 'top';
+            options.type = 'info';
+            options.show = true;
+
+            var myAlert = $alert();
+        }
+
+        function $alertConfig($alertProvider: ngStrap.alert.IAlertProvider): void {
+            var defaults: ngStrap.alert.IAlertOptions = {};
+            defaults.animation = 'am-fade-and-slide-top';
+            defaults.placement = 'top';
+
+            angular.extend($alertProvider.defaults, defaults);
+        };
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Tooltip
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module tooltipTests {
+
+        angular.module('demoApp')
+            .config($tooltipConfig)
+            .controller('demoDrct', demoDrct);
+
+        function demoDrct($tooltip: ngStrap.tooltip.ITooltipService): ng.IDirective {
+            var drct: ng.IDirective = {};
+            drct.restrict = 'EA';
+            drct.link = link;
+            return drct;
+            
+            function link(scope: ng.IScope, elem: ng.IAugmentedJQuery, attrs: ng.IAttributes): void {
+                var options: ngStrap.tooltip.ITooltipOptions = {};
+                options.title = 'My Title';
+                $tooltip(elem, options);
+            }
+        }
+
+        function $tooltipConfig($tooltipProvider: ngStrap.tooltip.ITooltipProvider): void {          
+            var defaults: ngStrap.tooltip.ITooltipOptions = {};
+            defaults.animation = 'am-flip-x';
+            defaults.trigger = 'hover';
+            
+            angular.extend($tooltipProvider.defaults, defaults);
+        };
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Popover
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module popoverTests {
+
+        angular.module('demoApp')
+            .config($popoverConfig)
+            .controller('demoDrct', demoDrct);
+
+        function demoDrct($popover: ngStrap.popover.IPopoverService): ng.IDirective {
+            var drct: ng.IDirective = {};
+            drct.restrict = 'EA';
+            drct.link = link;
+            return drct;
+            
+            function link(scope: ng.IScope, elem: ng.IAugmentedJQuery, attrs: ng.IAttributes): void {       
+                var options: ngStrap.tooltip.ITooltipOptions = {};
+                options.title = 'My Title';
+                    
+                $popover(elem, options);
+            }
+        }
+
+        function $popoverConfig($popoverProvider: ngStrap.popover.IPopoverProvider): void {
+            var defaults: ngStrap.tooltip.ITooltipOptions = {}
+            defaults.animation = 'am-flip-x';
+            defaults.trigger = 'hover';
+
+            angular.extend($popoverProvider.defaults, defaults);
+        };
+    }
+    
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Typeahead
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module typeaheadTests {
+            
+        angular.module('myApp')
+            .config($typeaheadConfig);
+                
+        function $typeaheadConfig($typeaheadProvider: ngStrap.typeahead.ITypeaheadProvider) {        
+          var defaults: ngStrap.typeahead.ITypeaheadOptions = {}
+          defaults.animation = 'am-flip-x';
+          defaults.minLength = 2;
+          defaults.limit = 8;
+          
+          angular.extend($typeaheadProvider.defaults, defaults);
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Datepicker
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module datepickerTests {
+        
+        angular.module('myApp')
+            .config($datepickerConfig);
+            
+        function $datepickerConfig($datepickerProvider: ngStrap.datepicker.IDatepickerProvider): void {
+            var defaults: ngStrap.datepicker.IDatepickerOptions = {};
+            defaults.dateFormat = 'dd/MM/yyyy';
+            defaults.startWeek = 1;
+    
+            angular.extend($datepickerProvider.defaults, defaults);
+        };
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Timepicker
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module timepickerTests {
+        
+        angular.module('myApp')
+            .config($timepickerConfig);
+            
+        function $timepickerConfig($timepickerProvider: ngStrap.timepicker.ITimepickerProvider): void {
+            var defaults: ngStrap.timepicker.ITimepickerOptions = {};
+            defaults.timeFormat = 'HH:mm';
+            defaults.length = 7;
+    
+            angular.extend($timepickerProvider.defaults, defaults);
+        };
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Select
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module selectTests {
+        
+        angular.module('myApp')
+            .config($selectConfig);
+        
+        function $selectConfig($selectProvider: ngStrap.select.ISelectProvider): void {
+            var defaults: ngStrap.select.ISelectOptions = {};
+            defaults.animation = 'am-flip-x';
+            defaults.sort = false;
+                       
+            angular.extend($selectProvider.defaults, defaults);
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Tabs
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module tabTests {
+        
+        angular.module('myApp')
+            .config($tabConfig);
+            
+        function $tabConfig($tabProvider: ngStrap.tab.ITabProvider) {
+          var defaults: ngStrap.tab.ITabOptions = {};
+          defaults.animation = 'am-flip-x';
+          
+          angular.extend($tabProvider.defaults, defaults);
+        }
+    }
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Collapse
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module collapseTests {
+        
+        angular.module('myApp')
+            .config($collapseConfig);
+            
+        function $collapseConfig($collapseProvider: ngStrap.collapse.ICollapseProvider):void {
+              var defaults: ngStrap.collapse.ICollapseOptions = {};
+              defaults.animation = 'am-flip-x';
+              
+              angular.extend($collapseProvider.defaults, defaults);
+            }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Dropdown
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module dropdownTests {
+        
+        angular.module('myApp')
+            .config($dropdownConfig);
+            
+        function $dropdownConfig($dropdownProvider: ngStrap.dropdown.IDropdownProvider):void {
+          var defaults: ngStrap.dropdown.IDropdownOptions = {};
+          defaults.animation = 'am-flip-x';
+          defaults.trigger = 'hover';
+          
+          angular.extend($dropdownProvider.defaults, defaults);
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Navbar
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module navbarTests {
+        
+        angular.module('myApp')
+            .config($navbarConfig);
+            
+        function $navbarConfig($navbarProvider: ngStrap.navbar.INavbarProvider):void {
+          var defaults: ngStrap.navbar.INavbarOptions = {};
+          defaults.activeClass = 'in';
+          
+          angular.extend($navbarProvider.defaults, defaults);
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Scrollspy
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module scrollspyTests {
+        
+        angular.module('myApp')
+            .config($scrollspyConfig);
+            
+        function $scrollspyConfig($scrollspyProvider: ngStrap.scrollspy.IScrollspyProvider):void {
+          var defaults: ngStrap.scrollspy.IScrollspyOptions = {};
+          defaults.offset = 0;
+          defaults.target = 'my-selector';
+          
+          angular.extend($scrollspyProvider.defaults, defaults);
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Affix
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module affixTests {
+        
+        angular.module('myApp')
+            .config($affixConfig);
+            
+        function $affixConfig($affixProvider: ngStrap.affix.IAffixProvider):void {
+          var defaults: ngStrap.affix.IAffixOptions = {};
+          defaults.offsetTop = 100;
+          
+          angular.extend($affixProvider.defaults, defaults);
+        }
+    }
+}

angular-strap/angular-strap.d.ts

@@ -0,0 +1,600 @@
+// Type definitions for angular-strap v2.2.x
+// Project: http://mgcrea.github.io/angular-strap/
+// Definitions by: Sam Herrmann <https://github.com/samherrmann>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module mgcrea.ngStrap {
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Modal
+    // see http://mgcrea.github.io/angular-strap/#/modals
+    ///////////////////////////////////////////////////////////////////////////
+
+    module modal {
+        
+        interface IModalService {
+            (config?: IModalOptions): IModal;
+        }
+    
+        interface IModalProvider {
+            defaults: IModalOptions;
+        }
+    
+        interface IModal {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+    
+        interface IModalOptions {
+            animation?: string;
+            backdropAnimation?: string;
+            placement?: string;
+            title?: string;
+            content?: string;
+            html?: boolean;
+            backdrop?: boolean | string;
+            keyboard?: boolean;
+            show?: boolean;
+            container?: string | boolean;
+            template?: string;
+            contentTemplate?: string;
+            prefixEvent?: string;
+            id?: string;
+            scope?: ng.IScope;
+        }
+    
+        interface IModalScope extends ng.IScope {
+            $show: () => void;
+            $hide: () => void;
+            $toggle: () => void;
+        }
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Aside
+    // see http://mgcrea.github.io/angular-strap/#/asides
+    ///////////////////////////////////////////////////////////////////////////
+
+    module aside {
+        
+        interface IAsideService {
+            (config?: IAsideOptions): IAside;
+        }
+    
+        interface IAsideProvider {
+            defaults: IAsideOptions;
+        }
+    
+        interface IAside {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+    
+        interface IAsideOptions {
+            animation?: string;
+            placement?: string;
+            title?: string;
+            content?: string;
+            html?: boolean;
+            backdrop?: boolean | string;
+            keyboard?: boolean;
+            show?: boolean;
+            container?: string | boolean;
+            template?: string;
+            contentTemplate?: string;
+            scope?: ng.IScope;
+        }
+    
+        interface IAsideScope extends ng.IScope {
+            $show: () => void;
+            $hide: () => void;
+            $toggle: () => void;
+        }
+    }
+
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Alert
+    // see http://mgcrea.github.io/angular-strap/#/alerts
+    ///////////////////////////////////////////////////////////////////////////
+
+    module alert {
+        
+        interface IAlertService {
+            (config?: IAlertOptions): IAlert;
+        }
+    
+        interface IAlertProvider {
+            defaults: IAlertOptions;
+        }
+    
+        interface IAlert {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+    
+        interface IAlertOptions {
+            animation?: string;
+            placement?: string;
+            title?: string;
+            content?: string;
+            type?: string;
+            keyboard?: boolean;
+            show?: boolean;
+            container?: string | boolean;
+            template?: string;
+            duration?: number | boolean;
+            dismissable?: boolean;
+        }
+    
+        interface IAlertScope extends ng.IScope {
+            $show: () => void;
+            $hide: () => void;
+            $toggle: () => void;
+        }
+    }
+    
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Tooltip
+    // see http://mgcrea.github.io/angular-strap/#/tooltips
+    ///////////////////////////////////////////////////////////////////////////
+
+    module tooltip {
+   
+        interface ITooltipService {
+            (element: ng.IAugmentedJQuery, config?: ITooltipOptions): ITooltip;
+        }
+    
+        interface ITooltipProvider {
+            defaults: ITooltipOptions;
+        }
+    
+        interface ITooltip {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+    
+        interface ITooltipOptions {
+            animation?: string;
+            placement?: string;
+            trigger?: string;
+            title?: string;
+            html?: boolean;
+            delay?: number | { show: number; hide: number};
+            container?: string | boolean;
+            target?: string | ng.IAugmentedJQuery | boolean;
+            template?: string;
+            contentTemplate?: string;
+            prefixEvent?: string;
+            id?: string;
+            viewport?: string | { selector: string; padding: string | number };
+        }
+    
+        interface ITooltipScope extends ng.IScope {
+            $show: () => void;
+            $hide: () => void;
+            $toggle: () => void;
+            $setEnabled: (isEnabled: boolean) => void;
+        }     
+    }
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Popover
+    // see http://mgcrea.github.io/angular-strap/#/popovers
+    ///////////////////////////////////////////////////////////////////////////
+
+    module popover {
+        
+        interface IPopoverService {
+            (element: ng.IAugmentedJQuery, config?: IPopoverOptions): IPopover;
+        }
+    
+        interface IPopoverProvider {
+            defaults: IPopoverOptions;
+        }
+    
+        interface IPopover {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+        
+        interface IPopoverOptions {
+            animation?: string;
+            placement?: string;
+            trigger?: string;
+            title?: string;
+            content?: string;
+            html?: boolean;
+            delay?: number | { show: number; hide: number };
+            container?: string | boolean;
+            target?: string | ng.IAugmentedJQuery | boolean;
+            template?: string;
+            contentTemplate?: string;
+            autoClose?: boolean;
+            id?: string;
+            viewport?: string | { selector: string; padding: string | number };
+        }
+    
+        interface IPopoverScope extends ng.IScope {
+            $show: () => void;
+            $hide: () => void;
+            $toggle: () => void;
+        }
+    }
+
+
+
+    ///////////////////////////////////////////////////////////////////////////
+    // Typeahead
+    // see http://mgcrea.github.io/angular-strap/#/typeaheads
+    ///////////////////////////////////////////////////////////////////////////
+
+    module typeahead {
+        
+        interface ITypeaheadService {
+            (element: ng.IAugmentedJQuery, controller: any, config?: ITypeaheadOptions): ITypeahead;
+        }
+    
+        interface ITypeaheadProvider {
+            defaults: ITypeaheadOptions;
+        }
+    
+        interface ITypeahead {
+            $promise: ng.IPromise<void>;
+            show: () => void;
+            hide: () => void;
+            toggle: () => void;
+        }
+    
+        interface ITypeaheadOptions {
+            animation?: string;
+            placement?: string;
+            trigger?: string;
+            html?: boolean;
+            delay?: number | { show: number; hide: number };
+            container?: string | boolean;
+            template?: string;
+            limit?: number;
+            minLength?: number;
+            autoSelect?: boolean;
+            comparator?: string;
+            id?: string;
+            watchOptions?: boolean;
+        }
+    }
+
+        
+    ///////////////////////////////////////////////////////////////////////////
+    // Datepicker
+    // see http://mgcrea.github.io/angular-strap/#/datepickers
+    ///////////////////////////////////////////////////////////////////////////
+
+    module datepicker {
+        
+        interface IDatepickerService {
+            (element: ng.IAugmentedJQuery, controller: any, config?: IDatepickerOptions): IDatepicker;
+        }
+    
+        interface IDatepickerProvider {
+            defaults: IDatepickerOptions;
+        }
+    
+        interface IDatepicker {
+            update: (date: Date) => void;      
+            updateDisabledDates: (dateRanges: IDatepickerDateRange[]) => void;     
+            select: (dateConstructorArg: string | number | number[], keep: boolean) => void;
+            setMode: (mode: any) => void; 
+            int: () => void;
+            destroy: () => void;
+            show: () => void;
+            hide: () => void;
+        }
+        
+        interface IDatepickerDateRange {
+            start: Date;
+            end: Date;
+        }
+    
+        interface IDatepickerOptions {
+            animation?: string;
+            placement?: string;
+            trigger?: string;
+            html?: boolean;
+            delay?: number | { show: number; hide: number };
+            container?: string | boolean;
+            template?: string;
+            dateFormat?: string;
+            modelDateFormat?: string;
+            dateType?: string;
+            timezone?: string;
+            autoclose?: boolean;
+            useNative?: boolean;
+            minDate?: Date;
+            maxDate?: Date;
+            startView?: number;
+            minView?: number;
+            startWeek?: number;
+            startDate?: Date;
+            iconLeft?: string;
+            iconRight?: string;
+            daysOfWeekDisabled?: string;
+            disabledDates?: IDatepickerDateRange[];
+        }
+    }
+
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Timepicker
+    // see http://mgcrea.github.io/angular-strap/#/timepickers
+    ///////////////////////////////////////////////////////////////////////////
+
+    module timepicker {
+
+        interface ITimepickerService {
+            (element: ng.IAugmentedJQuery, controller: any, config?: ITimepickerOptions): ITimepicker;
+        }
+    
+        interface ITimepickerProvider {
+            defaults: ITimepickerOptions;
+        }
+        
+        interface ITimepicker {
+            
+        }
+    
+        interface ITimepickerOptions {
+            animation?: string;
+            placement?: string;
+            trigger?: string;
+            html?: boolean;
+            delay?: number | { show: number; hide: number; };
+            container?: string | boolean;
+            template?: string;
+            timeFormat?: string;
+            modelTimeFormat?: string;
+            timeType?: string;
+            autoclose?: boolean;
+            useNative?: boolean;
+            minTime?: Date; // TODO
+            maxTime?: Date; // TODO
+            length?: number;
+            hourStep?: number;
+            minuteStep?: number;
+            secondStep?: number;
+            roundDisplay?: boolean;
+            iconUp?: string;
+            iconDown?: string;
+            arrowBehaviour?: string;
+        }      
+    }
+
+   
+    ///////////////////////////////////////////////////////////////////////////
+    // Button
+    // see http://mgcrea.github.io/angular-strap/#/buttons
+    ///////////////////////////////////////////////////////////////////////////
+
+    // No definitions for this module
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Select
+    // see http://mgcrea.github.io/angular-strap/#/selects
+    ///////////////////////////////////////////////////////////////////////////
+
+    module select {
+        
+        interface ISelectService {
+            (element: ng.IAugmentedJQuery, controller: any, config: ISelectOptions): ISelect;
+        }
+        
+        interface ISelectProvider {
+            defaults: ISelectOptions;
+        }
+        
+        interface ISelect {
+            update: (matches: any) => void;
+            active: (index: number) => number;
+            select: (index: number) => void;
+            show: () => void;
+            hide: () => void;
+        }
+                
+        interface ISelectOptions {
+          animation?: string;
+          placement?: string;
+          trigger?: string;
+          html?: boolean;
+          delay?: number | { show: number; hide: number; };
+          container?: string | boolean;
+          template?: string;
+          multiple?: boolean;
+          allNoneButtons?: boolean;
+          allText?: string;
+          noneText?: string;
+          maxLength?: number;
+          maxLengthHtml?: string;
+          sort?: boolean;
+          placeholder?: string;
+          iconCheckmark?: string;
+          id?: string;
+        }
+    }
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Tabs
+    // see http://mgcrea.github.io/angular-strap/#/tabs
+    ///////////////////////////////////////////////////////////////////////////
+
+    module tab {
+        
+        interface ITabProvider {
+            defaults: ITabOptions;
+        }
+        
+        interface ITabService {
+            defaults: ITabOptions;
+            controller: any;
+        }
+        
+        interface ITabOptions {
+            animation?: string;
+            template?: string;
+            navClass?: string;
+            activeClass?: string;
+        }
+    }
+    
+        
+    ///////////////////////////////////////////////////////////////////////////
+    // Collapses
+    // see http://mgcrea.github.io/angular-strap/#/collapses
+    ///////////////////////////////////////////////////////////////////////////
+
+    module collapse {
+        
+        interface ICollapseProvider {
+            defaults: ICollapseOptions;
+        }
+        
+        interface ICollapseOptions {
+            animation?: string;
+            activeClass?: string;
+            disallowToggle?: boolean;
+            startCollapsed?: boolean;
+            allowMultiple?: boolean;
+        }
+    }
+    
+            
+    ///////////////////////////////////////////////////////////////////////////
+    // Dropdowsn
+    // see http://mgcrea.github.io/angular-strap/#/dropdowns
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module dropdown {
+        
+        interface IDropdownProvider {
+            defaults: IDropdownOptions;
+        }
+             
+        interface IDropdownService {
+            (element: ng.IAugmentedJQuery, config: IDropdownOptions): IDropdown;
+        }
+        
+        interface IDropdown {
+            show: () => void;
+            hide: () => void;
+            destroy: () => void;
+        }
+        
+        interface IDropdownOptions {
+          animation?: string;
+          placement?: string;
+          trigger?: string;
+          html?: boolean;
+          delay?: number | { show: number; hide: number; };
+          container?: string | boolean;
+          template?: string;
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Navbar
+    // see http://mgcrea.github.io/angular-strap/#/navbars
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module navbar {
+        
+        interface INavbarProvider {
+            defaults: INavbarOptions;
+        }
+        
+        interface INavbarOptions {
+            activeClass?: string;
+            routeAttr?: string;
+        }
+        
+        interface INavbarService {
+            defaults: INavbarOptions;
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Scrollspy
+    // see http://mgcrea.github.io/angular-strap/#/scrollspy
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module scrollspy {
+        
+        interface IScrollspyProvider {
+            defaults: IScrollspyOptions;
+        }
+        
+        interface IScrollspyService {
+            (element: ng.IAugmentedJQuery, options: IScrollspyOptions): IScrollspy;
+        }
+        
+        interface IScrollspy {
+            checkOffsets: () => void;
+            trackElement: (target: any, source: any) => void;
+            untrackElement: (target: any, source: any) => void;
+            activate: (index: number)  => void;
+        }
+        
+        interface IScrollspyOptions {
+            target?: string;
+            offset?: number;
+        }
+    }
+    
+    
+    ///////////////////////////////////////////////////////////////////////////
+    // Affix
+    // see http://mgcrea.github.io/angular-strap/#/affix
+    ///////////////////////////////////////////////////////////////////////////
+    
+    module affix {
+        
+        interface IAffixProvider {
+            defaults: IAffixOptions;
+        }
+        
+        interface IAffixService {
+            (element: ng.IAugmentedJQuery, options: IAffixOptions): IAffix;
+        }
+        
+        interface IAffix {
+            init: () => void;
+            destroy: () => void;
+            checkPositionWithEventLoop: () => void;
+            checkPosition: () => void;
+        }
+        
+        interface IAffixOptions {
+            offsetTop?: number;
+            offsetBottom?: number;
+            offsetParent?: number;
+            offsetUnpin?: number;
+        }
+    }
+}

angular-toastr/angular-toastr-tests.ts

@@ -0,0 +1,64 @@
+/// <reference path='../angularjs/angular.d.ts' />
+/// <reference path='angular-toastr.d.ts' />
+
+
+angular
+    .module('toastr-tests', ['toastr'])
+    .config(function(toastrConfig: angular.toastr.IToastrConfig) {
+        let toastContainerConfig: angular.toastr.IToastContainerConfig = {
+            autoDismiss: false,
+            containerId: 'toast-container',
+            maxOpened: 0,
+            newestOnTop: true,
+            positionClass: 'toast-top-right',
+            preventDuplicates: false,
+            preventOpenDuplicates: false,
+            target: 'body'
+        },
+            toastConfig: angular.toastr.IToastConfig = {
+            allowHtml: false,
+            closeButton: false,
+            closeHtml: '<button>&times;</button>',
+            extendedTimeOut: 1000,
+            iconClasses: {
+                error: 'toast-error',
+                info: 'toast-info',
+                success: 'toast-success',
+                warning: 'toast-warning'
+            },
+            messageClass: 'toast-message',
+            onHidden: null,
+            onShown: null,
+            onTap: null,
+            progressBar: false,
+            tapToDismiss: true,
+            templates: {
+
+                toast: 'directives/toast/toast.html',
+                progressbar: 'directives/progressbar/progressbar.html'
+            },
+            timeOut: 5000,
+            titleClass: 'toast-title',
+            toastClass: 'toast'
+        };
+
+        angular.extend(toastrConfig, toastContainerConfig, toastConfig);
+    })
+    .controller('ToastrController', function(toastr: angular.toastr.IToastrService) {
+        toastr.info('<input type="checkbox" checked> Success!', 'With HTML', {
+            allowHtml: true
+        });
+
+        toastr.success('What a nice button', 'Button spree', {
+            closeButton: true
+        });
+
+        toastr.info('What a nice apple button', 'Button spree', {
+            closeButton: true,
+            closeHtml: '<button></button>'
+        });
+
+        toastr.info('I am totally custom!', 'Happy toast', {
+            iconClass: 'toast-pink'
+        });
+    });

angular-toastr/angular-toastr.d.ts

@@ -0,0 +1,121 @@
+// Type definitions for Angular Toastr v1.6.0
+// Project: https://github.com/Foxandxss/angular-toastr
+// Definitions by: Niko Kovačič <https://github.com/nkovacic>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../angularjs/angular.d.ts" />
+
+declare module "angular-toastr" {
+    var _: string;
+    export = _;
+}
+
+interface IToastBaseConfig {
+    allowHtml?: boolean;
+    closeButton?: boolean;
+    closeHtml?: string;
+    extendedTimeOut?: number;
+    messageClass?: string;
+    onHidden?: Function;
+    onShown?: Function;
+    onTap?: Function;
+    progressBar?: boolean;
+    tapToDismiss?: boolean;
+    templates?: {
+        toast?: string;
+        progressbar?: string;
+    };
+    timeOut?: number;
+    titleClass?: string;
+    toastClass?: string;
+}
+
+declare module angular.toastr {
+    interface IToastContainerConfig {
+        autoDismiss?: boolean;
+        containerId?: string;
+        maxOpened?: number;
+        newestOnTop?: boolean;
+        positionClass?: string;
+        preventDuplicates?: boolean;
+        preventOpenDuplicates?: boolean;
+        target?: string;
+    }
+
+    interface IToastConfig extends IToastBaseConfig {
+        iconClasses?: {
+            error?: string;
+            info?: string;
+            success?: string;
+            warning?: string;
+        };
+    }
+
+    interface IToastrConfig extends IToastContainerConfig, IToastConfig { }
+
+    interface IToastScope extends angular.IScope {
+        message: string;
+        options: IToastConfig;
+        title: string;
+        toastId: number;
+        toastType: string;
+    }
+
+    interface IToast {
+        el: angular.IAugmentedJQuery;
+        iconClass: string;
+        isOpened: boolean;
+        open: angular.IPromise<any>;
+        scope: IToastScope;
+        toastId: number;
+    }
+
+    interface IToastOptions extends IToastBaseConfig {
+        iconClass?: string;
+    }
+
+    interface IToastrService {
+        /**
+         * Return the number of active toasts in screen.
+         */      
+        active(): number;
+        /**
+         * Remove toast from screen. If no toast is passed in, all toasts will be closed.
+         *
+         * @param {IToast} toast Optional toast object to delete
+         */ 
+        clear(toast?: IToast): void;
+        /**
+         * Create error toast notification message.
+         *
+         * @param {String} message Message to show on toast
+         * @param {String} title Title to show on toast
+         * @param {IToastOptions} options Override default toast options
+         */ 
+        error(message: string, title?: string, options?: IToastOptions): IToast;
+        /**
+         * Create info toast notification message.
+         *
+         * @param {String} message Message to show on toast
+         * @param {String} title Title to show on toast
+         * @param {IToastOptions} options Override default toast options
+         */ 
+        info(message: string, title?: string, options?: IToastOptions): IToast;
+        /**
+         * Create success toast notification message.
+         *
+         * @param {String} message Message to show on toast
+         * @param {String} title Title to show on toast
+         * @param {IToastOptions} options Override default toast options
+         */ 
+        success(message: string, title?: string, options?: IToastOptions): IToast;
+        /**
+         * Create warning toast notification message.
+         *
+         * @param {String} message Message to show on toast
+         * @param {String} title Title to show on toast
+         * @param {IToastOptions} options Override default toast options
+         */ 
+        warning(message: string, title?: string, options?: IToastOptions): IToast;
+    }
+}

angular-translate/angular-translate-tests.ts

@@ -36,4 +36,9 @@ app.controller('Ctrl', ($scope: Scope, $translate: angular.translate.ITranslateS
     $scope['changeLanguage'] = function (key: any) {
         $translate.use(key);
     };
+}).run(($filter: ng.IFilterService) => {
+    var x: string;
+    x = $filter('translate')('something');
+    x = $filter('translate')('something', {});
+    x = $filter('translate')('something', {}, '');
 });

angular-translate/angular-translate.d.ts

@@ -6,8 +6,8 @@
 /// <reference path="../angularjs/angular.d.ts" />
 
 declare module "angular-translate" {
-    var _: string;
-    export = _;
+    import ngt = angular.translate;
+    export = ngt;
 }
 
 declare module angular.translate {
@@ -22,7 +22,7 @@ declare module angular.translate {
 
     interface IStorage {
         get(name: string): string;
-        set(name: string, value: string): void;
+        put(name: string, value: string): void;
     }
 
     interface IStaticFilesLoaderOptions {
@@ -108,3 +108,11 @@ declare module angular.translate {
         useLoaderCache(cache?: any): ITranslateProvider;
     }
 }
+
+declare module angular {
+    interface IFilterService {
+        (name:'translate'): {
+            (translationId: string, interpolateParams?: any, interpolation?: string): string;
+        };
+    }
+}

angular-ui-router/angular-ui-router-tests.ts

@@ -70,6 +70,13 @@ myApp.config((
         $scope.items = ["A", "List", "Of", "Items"];
       }
     })
+    .state('state1.list', {
+      url: "/list",
+      templateUrl: "partials/state1.list.html",
+      controller: ['$scope', function ($scope: MyAppScope) {
+        $scope.items = ["A", "List", "Of", "Items"];
+      }]
+    })
     .state('state2', {
       url: "/state2",
       templateUrl: "partials/state2.html"
@@ -170,10 +177,15 @@ class UrlLocatorTestService implements IUrlLocatorTestService {
         if (this.$state.href("myState") === "/myState") {
           //
         }
-        this.$state.get("myState");
         this.$state.get();
+        this.$state.get("myState");
+        this.$state.get("myState", "yourState");
+        this.$state.get("myState", this.$state.current);
+        this.$state.get(this.$state.current);
+        this.$state.get(this.$state.current, "yourState");
+        this.$state.get(this.$state.current, this.$state.current);
         this.$state.reload();
-        
+
         // http://angular-ui.github.io/ui-router/site/#/api/ui.router.state.$state#properties
         if (this.$state.transition) {
           var transitionPromise: ng.IPromise<{}> = this.$state.transition;
@@ -187,7 +199,7 @@ class UrlLocatorTestService implements IUrlLocatorTestService {
             // transition ended (success or failure)
           });
         }
-        
+
         // Accesses the currently resolved values for the current state
         // http://stackoverflow.com/questions/28026620/is-there-a-way-to-access-resolved-state-dependencies-besides-injecting-them-into/28027023#28027023
         var resolvedValues = this.$state.$current.locals.globals;
@@ -223,7 +235,7 @@ module UrlRouterProviderTests {
         // this allows you to configure custom behavior in between
         // location changes and route synchronization:
         $urlRouterProvider.deferIntercept();
-    }).run(($rootScope: ng.IRootScopeService, $urlRouter: ng.ui.IUrlRouterService, UserService: ITestUserService) => {
+    }).run(($rootScope: ng.IRootScopeService, $urlRouter: ng.ui.IUrlRouterService, UserService: ITestUserService, $urlMatcher: ng.ui.IUrlMatcher) => {
         $rootScope.$on('$locationChangeSuccess', e => {
             // UserService is an example service for managing user state
             if (UserService.isLoggedIn()) return;
@@ -238,6 +250,18 @@ module UrlRouterProviderTests {
         });
 
         // Configures $urlRouter's listener *after* your custom listener
-        $urlRouter.listen();
+        var listen: Function = $urlRouter.listen();
+
+        var href: string;
+        href = $urlRouter.href($urlMatcher);
+        href = $urlRouter.href($urlMatcher, {});
+        href = $urlRouter.href($urlMatcher, {}, {});
+
+        $urlRouter.update();
+        $urlRouter.update(false);
+
+        $urlRouter.push($urlMatcher);
+        $urlRouter.push($urlMatcher, {});
+        $urlRouter.push($urlMatcher, {}, {});
     });
 }

angular-ui-router/angular-ui-router.d.ts

@@ -5,10 +5,27 @@
 
 /// <reference path="../angularjs/angular.d.ts" />
 
-// Support for AMD require
+// Support for AMD require and CommonJS
 declare module 'angular-ui-router' {
-    var _: string;
-    export = _;
+    // Since angular-ui-router adds providers for a bunch of
+    // injectable dependencies, it doesn't really return any
+    // actual data except the plain string 'ui.router'.
+    //
+    // As such, I don't think anybody will ever use the actual
+    // default value of the module.  So I've only included the
+    // the types. (@xogeny)
+    export type IState = angular.ui.IState;
+    export type IStateProvider = angular.ui.IStateProvider;
+    export type IUrlMatcher = angular.ui.IUrlMatcher;
+    export type IUrlRouterProvider = angular.ui.IUrlRouterProvider;
+    export type IStateOptions = angular.ui.IStateOptions;
+    export type IHrefOptions = angular.ui.IHrefOptions;
+    export type IStateService = angular.ui.IStateService;
+    export type IResolvedState = angular.ui.IResolvedState;
+    export type IStateParamsService = angular.ui.IStateParamsService;
+    export type IUrlRouterService = angular.ui.IUrlRouterService;
+    export type IUiViewScrollProvider = angular.ui.IUiViewScrollProvider;
+    export type IType = angular.ui.IType;
 }
 
 declare module angular.ui {
@@ -26,24 +43,24 @@ declare module angular.ui {
         /**
          * Function, returns HTML content string
          */
-        templateProvider?: Function | Array<any>;
+        templateProvider?: Function | Array<string|Function>;
         /**
-         * A controller paired to the state. Function OR name as String
+         * A controller paired to the state. Function, annotated array or name as String
          */
-        controller?: Function | string;
+        controller?: Function|string|Array<string|Function>;
         controllerAs?: string;
         /**
          * Function (injectable), returns the actual controller function or string.
          */
-        controllerProvider?: Function;
-        
+        controllerProvider?: Function|Array<string|Function>;
+
         /**
          * Specifies the parent state of this state
          */
-        parent?: string | IState
-        
-        
-        resolve?: {};
+        parent?: string | IState;
+
+
+        resolve?: { [name:string]: any };
         /**
          * A url with optional parameters. When a state is navigated or transitioned to, the $stateParams service will be populated with any parameters that were passed.
          */
@@ -55,26 +72,32 @@ declare module angular.ui {
         /**
          * Use the views property to set up multiple views. If you don't need multiple views within a single state this property is not needed. Tip: remember that often nested views are more useful and powerful than multiple sibling views.
          */
-        views?: {};
+        views?: { [name:string]: IState };
         abstract?: boolean;
         /**
          * Callback function for when a state is entered. Good way to trigger an action or dispatch an event, such as opening a dialog.
          * If minifying your scripts, make sure to explicitly annotate this function, because it won't be automatically annotated by your build tools.
          */
-        onEnter?: Function|(string|Function)[];
+        onEnter?: Function|Array<string|Function>;
         /**
          * Callback functions for when a state is entered and exited. Good way to trigger an action or dispatch an event, such as opening a dialog.
          * If minifying your scripts, make sure to explicitly annotate this function, because it won't be automatically annotated by your build tools.
          */
-        onExit?: Function|(string|Function)[];
+        onExit?: Function|Array<string|Function>;
         /**
          * Arbitrary data object, useful for custom configuration.
          */
         data?: any;
+        
         /**
          * Boolean (default true). If false will not re-trigger the same state just because a search/query parameter has changed. Useful for when you'd like to modify $location.search() without triggering a reload.
          */
         reloadOnSearch?: boolean;
+        
+        /**
+         * Boolean (default true). If false will reload state on everytransitions. Useful for when you'd like to restore all data  to its initial state.
+         */
+        cache?: boolean;
     }
 
     interface IStateProvider extends angular.IServiceProvider {
@@ -229,29 +252,32 @@ declare module angular.ui {
          */
         go(to: string, params?: {}, options?: IStateOptions): angular.IPromise<any>;
         go(to: IState, params?: {}, options?: IStateOptions): angular.IPromise<any>;
-        transitionTo(state: string, params?: {}, updateLocation?: boolean): void;
-        transitionTo(state: IState, params?: {}, updateLocation?: boolean): void;
-        transitionTo(state: string, params?: {}, options?: IStateOptions): void;
-        transitionTo(state: IState, params?: {}, options?: IStateOptions): void;
+        transitionTo(state: string, params?: {}, updateLocation?: boolean): angular.IPromise<any>;
+        transitionTo(state: IState, params?: {}, updateLocation?: boolean): angular.IPromise<any>;
+        transitionTo(state: string, params?: {}, options?: IStateOptions): angular.IPromise<any>;
+        transitionTo(state: IState, params?: {}, options?: IStateOptions): angular.IPromise<any>;
         includes(state: string, params?: {}): boolean;
         is(state:string, params?: {}): boolean;
         is(state: IState, params?: {}): boolean;
         href(state: IState, params?: {}, options?: IHrefOptions): string;
         href(state: string, params?: {}, options?: IHrefOptions): string;
-        get(state: string): IState;
+        get(state: string, context?: string): IState;
+        get(state: IState, context?: string): IState;
+        get(state: string, context?: IState): IState;
+        get(state: IState, context?: IState): IState;
         get(): IState[];
         /** A reference to the state's config object. However you passed it in. Useful for accessing custom data. */
         current: IState;
         /** A param object, e.g. {sectionId: section.id)}, that you'd like to test against the current active state. */
         params: IStateParamsService;
-        reload(): void;
-        
+        reload(): angular.IPromise<any>;
+
         /** Currently pending transition. A promise that'll resolve or reject. */
-        transition: ng.IPromise<{}>;
-        
+        transition: angular.IPromise<{}>;
+
         $current: IResolvedState;
     }
-    
+
     interface IResolvedState {
         locals: {
             /**
@@ -277,7 +303,10 @@ declare module angular.ui {
     	 *
     	 */
         sync(): void;
-        listen(): void;
+        listen(): Function;
+        href(urlMatcher: IUrlMatcher, params?: IStateParamsService, options?: IHrefOptions): string;
+        update(read?: boolean): void;
+        push(urlMatcher: IUrlMatcher, params?: IStateParamsService, options?: IHrefOptions): void;
     }
 
     interface IUiViewScrollProvider {

angular-ui-tree/angular-ui-tree-tests.ts

@@ -11,3 +11,73 @@ var treeNode2: AngularUITree.ITreeNode = {
     nodes: [treeNode],
     title: "test2"
 };
+
+// fake jquery node here so that we can pull a pretend
+// angular scope element out of it
+var dummyJQueryNode: ng.IAugmentedJQuery;
+var fakeScope: (ng.IScope | AngularUITree.IParentTreeNodeScope) = dummyJQueryNode.scope();
+
+(<AngularUITree.ITreeNodeScope> fakeScope).node = treeNode;
+
+var treeNodeScope: AngularUITree.ITreeNodeScope = <AngularUITree.ITreeNodeScope> fakeScope;
+
+(<AngularUITree.IParentTreeNodeScope> fakeScope).isParent = (nodeScope: AngularUITree.ITreeNodeScope) => {
+    return true;
+};
+
+var parentTreeNodeScope: AngularUITree.IParentTreeNodeScope = <AngularUITree.IParentTreeNodeScope> fakeScope;
+
+var eventSourceInfo: AngularUITree.IEventSourceInfo = {
+    cloneModel: {},
+    nodeScope: treeNodeScope,
+    index: 0,
+    nodesScope: parentTreeNodeScope
+};
+
+var position: AngularUITree.IPosition = {
+    dirAx: 0,
+    dirX: 0,
+    dirY: 0,
+    distAxX: 0,
+    distAxY: 0,
+    distX: 0,
+    distY: 0,
+    lastDirX: 0,
+    lastDirY: 0,
+    lastX: 0,
+    lastY: 0,
+    moving: true,
+    nowX: 0,
+    nowY: 0,
+    offsetX: 0,
+    offsetY: 0,
+    startX: 0,
+    startY: 0
+
+};
+
+var eventInfo: AngularUITree.IEventInfo = {
+    source: eventSourceInfo,
+    dest: {
+        index: 0,
+        nodesScope: parentTreeNodeScope
+    },
+    elements: {},
+    pos: position
+};
+
+var acceptCallback: AngularUITree.IAcceptCallback = (source: AngularUITree.ITreeNodeScope,
+                                                     destination: AngularUITree.ITreeNodeScope,
+                                                     destinationIndex: number) => {
+    return false;
+};
+
+var droppedCallback: AngularUITree.IDroppedCallback = (eventInfo: AngularUITree.IEventInfo) => {
+    return;
+};
+
+var callbacks: AngularUITree.ICallbacks = {
+    accept: acceptCallback,
+    dragStart: droppedCallback,
+    dropped: droppedCallback
+};

angular-ui-tree/angular-ui-tree.d.ts

@@ -3,7 +3,72 @@
 // Definitions by: Calvin Fernandez <https://github.com/CalvinFernandez>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+/// <reference path='../angularjs/angular.d.ts' />
+
 declare module AngularUITree {
+    interface IEventSourceInfo {
+        cloneModel: any;
+        index: number;
+        nodeScope: ITreeNodeScope;
+        nodesScope: ITreeNodeScope;
+    }
+
+    interface IPosition {
+        dirAx: number;
+        dirX: number;
+        dirY: number;
+        distAxX: number;
+        distAxY: number;
+        distX: number;
+        distY: number;
+        lastDirX: number;
+        lastDirY: number;
+        lastX: number;
+        lastY: number;
+        moving: boolean;
+        nowX: number;
+        nowY: number;
+        offsetX: number;
+        offsetY: number;
+        startX: number;
+        startY: number;
+    }
+
+    interface IEventInfo {
+        dest: {
+            index: number;
+            nodesScope: IParentTreeNodeScope;
+        };
+        elements: any;
+        pos: IPosition;
+        source: IEventSourceInfo;
+    }
+
+    interface IAcceptCallback {
+        (source: ITreeNodeScope, destination: ITreeNodeScope, destinationIndex: number): boolean;
+    }
+
+    interface IDroppedCallback {
+        (eventInfo: IEventInfo): void;
+    }
+
+    interface ICallbacks {
+        accept: IAcceptCallback;
+        dragStart: IDroppedCallback;
+        dropped: IDroppedCallback;
+    }
+
+    /**
+     * Internal representation of node in the UI
+     */
+    interface ITreeNodeScope extends ng.IScope {
+        node: ITreeNode;
+    }
+
+    interface IParentTreeNodeScope extends ITreeNodeScope {
+        isParent(nodeScope: ITreeNodeScope): boolean;
+    }
+
     /**
       * Node in list
       */

angular2/angular2-tests.ts

@@ -1,43 +1,3 @@
 /// <reference path="angular2.d.ts"/>
-/// <reference path="router.d.ts"/>
 
-import {Component, View, Directive, bootstrap, bind, NgFor, NgIf} from "angular2/angular2";
-
-class Service {
-	
-}
-class Service2 {
-  
-}
-
-class Cmp {
-	static annotations: any[];
-}
-Cmp.annotations = [
-  Component({
-    selector: 'cmp',
-    bindings: [Service, bind(Service2).toValue(null)]
-  }),
-  View({
-    template: '{{greeting}} world!',
-    directives: [NgFor, NgIf]
-  }),
-  Directive({
-    selector: '[tooltip]',
-    properties: [
-      'text: tooltip'
-    ],
-    host: {
-      '(onmouseenter)': 'onMouseEnter()',
-      '(onmouseleave)': 'onMouseLeave()'
-    }
-  })
-];
-
-@Component({selector: 'cmp2'})
-@View({templateUrl: '/index.html'})
-class Cmp2 {
-  
-}
-
-bootstrap(Cmp);
+// No tests, because angular 2 typings are not in DefinitelyTyped.

angular2/http-2.0.0-alpha.37.d.ts

@@ -13,7 +13,7 @@
 // If you don't have them installed you can install them using TSD
 // https://github.com/DefinitelyTyped/tsd
 
-///<reference path="./angular2.d.ts"/>
+///<reference path="./angular2-2.0.0-alpha.37.d.ts"/>
 
 
 

angular2/router-2.0.0-alpha.31.d.ts

@@ -8,7 +8,7 @@
 // Please do not create manual edits or send pull requests
 // modifying this file.
 // ***********************************************************
-///<reference path="./angular2.d.ts"/>
+///<reference path="./angular2-2.0.0-alpha.31.d.ts"/>
 
 
 

angular2/router-2.0.0-alpha.35.d.ts

@@ -13,7 +13,7 @@
 // If you don't have them installed you can install them using TSD
 // https://github.com/DefinitelyTyped/tsd
 
-///<reference path="./angular2.d.ts"/>
+///<reference path="./angular2-2.0.0-alpha.35.d.ts"/>
 
 
 

angular2/router-2.0.0-alpha.36.d.ts

@@ -13,7 +13,7 @@
 // If you don't have them installed you can install them using TSD
 // https://github.com/DefinitelyTyped/tsd
 
-///<reference path="./angular2.d.ts"/>
+///<reference path="./angular2-2.0.0-alpha.36.d.ts"/>
 
 
 

angular2/router-2.0.0-alpha.37.d.ts

@@ -13,7 +13,7 @@
 // If you don't have them installed you can install them using TSD
 // https://github.com/DefinitelyTyped/tsd
 
-///<reference path="./angular2.d.ts"/>
+///<reference path="./angular2-2.0.0-alpha.37.d.ts"/>
 
 
 

angular2/router.d.ts

@@ -1,738 +0,0 @@
-// Type definitions for Angular v2.0.0-alpha.37
-// Project: http://angular.io/
-// Definitions by: angular team <https://github.com/angular/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-// ***********************************************************
-// This file is generated by the Angular build process.
-// Please do not create manual edits or send pull requests
-// modifying this file.
-// ***********************************************************
-
-// angular2/router depends transitively on these libraries.
-// If you don't have them installed you can install them using TSD
-// https://github.com/DefinitelyTyped/tsd
-
-///<reference path="./angular2.d.ts"/>
-
-
-
-
-/**
- * @module
- * @description
- * Maps application URLs into application states, to support deep-linking and navigation.
- */
-declare module ngRouter {
-
-  /**
-   * # Router
-   * The router is responsible for mapping URLs to components.
-   *
-   * You can see the state of the router by inspecting the read-only field `router.navigating`.
-   * This may be useful for showing a spinner, for instance.
-   *
-   * ## Concepts
-   * Routers and component instances have a 1:1 correspondence.
-   *
-   * The router holds reference to a number of "outlets." An outlet is a placeholder that the
-   * router dynamically fills in depending on the current URL.
-   *
-   * When the router navigates from a URL, it must first recognizes it and serialize it into an
-   * `Instruction`.
-   * The router uses the `RouteRegistry` to get an `Instruction`.
-   */
-  class Router {
-
-     navigating: boolean;
-
-     lastNavigationAttempt: string;
-
-     registry: RouteRegistry;
-
-     parent: Router;
-
-     hostComponent: any;
-
-
-    /**
-     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
-     * component.
-     */
-     childRouter(hostComponent: any): Router;
-
-
-    /**
-     * Constructs a child router. You probably don't need to use this unless you're writing a reusable
-     * component.
-     */
-     auxRouter(hostComponent: any): Router;
-
-
-    /**
-     * Register an outlet to notified of primary route changes.
-     *
-     * You probably don't need to use this unless you're writing a reusable component.
-     */
-     registerPrimaryOutlet(outlet: RouterOutlet): Promise<boolean>;
-
-
-    /**
-     * Register an outlet to notified of auxiliary route changes.
-     *
-     * You probably don't need to use this unless you're writing a reusable component.
-     */
-     registerAuxOutlet(outlet: RouterOutlet): Promise<boolean>;
-
-
-    /**
-     * Given an instruction, returns `true` if the instruction is currently active,
-     * otherwise `false`.
-     */
-     isRouteActive(instruction: Instruction): boolean;
-
-
-    /**
-     * Dynamically update the routing configuration and trigger a navigation.
-     *
-     * # Usage
-     *
-     * ```
-     * router.config([
-     *   { 'path': '/', 'component': IndexComp },
-     *   { 'path': '/user/:id', 'component': UserComp },
-     * ]);
-     * ```
-     */
-     config(definitions: RouteDefinition[]): Promise<any>;
-
-
-    /**
-     * Navigate to a URL. Returns a promise that resolves when navigation is complete.
-     *
-     * If the given URL begins with a `/`, router will navigate absolutely.
-     * If the given URL does not begin with `/`, the router will navigate relative to this component.
-     */
-     navigate(url: string, _skipLocationChange?: boolean): Promise<any>;
-
-
-    /**
-     * Navigate via the provided instruction. Returns a promise that resolves when navigation is
-     * complete.
-     */
-     navigateInstruction(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
-
-
-    /**
-     * Updates this router and all descendant routers according to the given instruction
-     */
-     commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
-
-
-    /**
-     * Subscribe to URL updates from the router
-     */
-     subscribe(onNext: (value: any) => void): Object;
-
-
-    /**
-     * Removes the contents of this router's outlet and all descendant outlets
-     */
-     deactivate(instruction: Instruction): Promise<any>;
-
-
-    /**
-     * Given a URL, returns an instruction representing the component graph
-     */
-     recognize(url: string): Promise<Instruction>;
-
-
-    /**
-     * Navigates to either the last URL successfully navigated to, or the last URL requested if the
-     * router has yet to successfully navigate.
-     */
-     renavigate(): Promise<any>;
-
-
-    /**
-     * Generate a URL from a component name and optional map of parameters. The URL is relative to the
-     * app's base href.
-     */
-     generate(linkParams: any[]): Instruction;
-  }
-
-  class RootRouter extends Router {
-
-     commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
-  }
-
-
-  /**
-   * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
-   *
-   * ## Use
-   *
-   * ```
-   * <router-outlet></router-outlet>
-   * ```
-   */
-  class RouterOutlet {
-
-     name: string;
-
-
-    /**
-     * Called by the Router to instantiate a new component during the commit phase of a navigation.
-     * This method in turn is responsible for calling the `onActivate` hook of its child.
-     */
-     activate(nextInstruction: ComponentInstruction): Promise<any>;
-
-
-    /**
-     * Called by the {@link Router} during the commit phase of a navigation when an outlet
-     * reuses a component between different routes.
-     * This method in turn is responsible for calling the `onReuse` hook of its child.
-     */
-     reuse(nextInstruction: ComponentInstruction): Promise<any>;
-
-
-    /**
-     * Called by the {@link Router} when an outlet reuses a component across navigations.
-     * This method in turn is responsible for calling the `onReuse` hook of its child.
-     */
-     deactivate(nextInstruction: ComponentInstruction): Promise<any>;
-
-
-    /**
-     * Called by the {@link Router} during recognition phase of a navigation.
-     *
-     * If this resolves to `false`, the given navigation is cancelled.
-     *
-     * This method delegates to the child component's `canDeactivate` hook if it exists,
-     * and otherwise resolves to true.
-     */
-     canDeactivate(nextInstruction: ComponentInstruction): Promise<boolean>;
-
-
-    /**
-     * Called by the {@link Router} during recognition phase of a navigation.
-     *
-     * If the new child component has a different Type than the existing child component,
-     * this will resolve to `false`. You can't reuse an old component when the new component
-     * is of a different Type.
-     *
-     * Otherwise, this method delegates to the child component's `canReuse` hook if it exists,
-     * or resolves to true if the hook is not present.
-     */
-     canReuse(nextInstruction: ComponentInstruction): Promise<boolean>;
-  }
-
-
-  /**
-   * The RouterLink directive lets you link to specific parts of your app.
-   *
-   * Consider the following route configuration:
-   *
-   * ```
-   * @RouteConfig([
-   *   { path: '/user', component: UserCmp, as: 'user' }
-   * ]);
-   * class MyComp {}
-   * ```
-   *
-   * When linking to this `user` route, you can write:
-   *
-   * ```
-   * <a [router-link]="['./user']">link to user component</a>
-   * ```
-   *
-   * RouterLink expects the value to be an array of route names, followed by the params
-   * for that level of routing. For instance `['/team', {teamId: 1}, 'user', {userId: 2}]`
-   * means that we want to generate a link for the `team` route with params `{teamId: 1}`,
-   * and with a child route `user` with params `{userId: 2}`.
-   *
-   * The first route name should be prepended with `/`, `./`, or `../`.
-   * If the route begins with `/`, the router will look up the route from the root of the app.
-   * If the route begins with `./`, the router will instead look in the current component's
-   * children for the route. And if the route begins with `../`, the router will look at the
-   * current component's parent.
-   */
-  class RouterLink {
-
-     visibleHref: string;
-
-     isRouteActive: boolean;
-
-     routeParams: any;
-
-     onClick(): boolean;
-  }
-
-  class RouteParams {
-
-     params: StringMap<string, string>;
-
-     get(param: string): string;
-  }
-
-
-  /**
-   * The RouteRegistry holds route configurations for each component in an Angular app.
-   * It is responsible for creating Instructions from URLs, and generating URLs based on route and
-   * parameters.
-   */
-  class RouteRegistry {
-
-
-    /**
-     * Given a component and a configuration object, add the route to this registry
-     */
-     config(parentComponent: any, config: RouteDefinition): void;
-
-
-    /**
-     * Reads the annotations of a component and configures the registry based on them
-     */
-     configFromComponent(component: any): void;
-
-
-    /**
-     * Given a URL and a parent component, return the most specific instruction for navigating
-     * the application into the state specified by the url
-     */
-     recognize(url: string, parentComponent: any): Promise<Instruction>;
-
-
-    /**
-     * Given a normalized list with component names and params like: `['user', {id: 3 }]`
-     * generates a url with a leading slash relative to the provided `parentComponent`.
-     */
-     generate(linkParams: any[], parentComponent: any): Instruction;
-  }
-
-  class LocationStrategy {
-
-     path(): string;
-
-     pushState(ctx: any, title: string, url: string): void;
-
-     forward(): void;
-
-     back(): void;
-
-     onPopState(fn: (_: any) => any): void;
-
-     getBaseHref(): string;
-  }
-
-  class HashLocationStrategy extends LocationStrategy {
-
-     onPopState(fn: EventListener): void;
-
-     getBaseHref(): string;
-
-     path(): string;
-
-     pushState(state: any, title: string, url: string): void;
-
-     forward(): void;
-
-     back(): void;
-  }
-
-  class PathLocationStrategy extends LocationStrategy {
-
-     onPopState(fn: EventListener): void;
-
-     getBaseHref(): string;
-
-     path(): string;
-
-     pushState(state: any, title: string, url: string): void;
-
-     forward(): void;
-
-     back(): void;
-  }
-
-
-  /**
-   * This is the service that an application developer will directly interact with.
-   *
-   * Responsible for normalizing the URL against the application's base href.
-   * A normalized URL is absolute from the URL host, includes the application's base href, and has no
-   * trailing slash:
-   * - `/my/app/user/123` is normalized
-   * - `my/app/user/123` **is not** normalized
-   * - `/my/app/user/123/` **is not** normalized
-   */
-  class Location {
-
-     platformStrategy: LocationStrategy;
-
-     path(): string;
-
-     normalize(url: string): string;
-
-     normalizeAbsolutely(url: string): string;
-
-     go(url: string): void;
-
-     forward(): void;
-
-     back(): void;
-
-     subscribe(onNext: (value: any) => void, onThrow?: (exception: any) => void, onReturn?: () => void): void;
-  }
-
-  const APP_BASE_HREF : OpaqueToken ;
-
-
-  /**
-   * Responsible for performing each step of navigation.
-   * "Steps" are conceptually similar to "middleware"
-   */
-  class Pipeline {
-
-     steps: Function[];
-
-     process(instruction: Instruction): Promise<any>;
-  }
-
-
-  /**
-   * Defines route lifecycle method [onActivate], which is called by the router at the end of a
-   * successful route navigation.
-   *
-   * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
-   * depending on the result of [canReuse].
-   *
-   * If `onActivate` returns a promise, the route change will wait until the promise settles to
-   * instantiate and activate child components.
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'my-cmp'
-   * })
-   * class MyCmp implements OnActivate {
-   *   onActivate(next, prev) {
-   *     this.log = 'Finished navigating from ' + prev.urlPath + ' to ' + next.urlPath;
-   *   }
-   * }
-   *  ```
-   */
-  interface OnActivate {
-
-     onActivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
-  }
-
-
-  /**
-   * Defines route lifecycle method [onDeactivate], which is called by the router before destroying
-   * a component as part of a route change.
-   *
-   * If `onDeactivate` returns a promise, the route change will wait until the promise settles.
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'my-cmp'
-   * })
-   * class MyCmp implements CanReuse, OnReuse {
-   *   canReuse() {
-   *     return true;
-   *   }
-   *
-   *   onReuse(next, prev) {
-   *     this.params = next.params;
-   *   }
-   * }
-   *  ```
-   */
-  interface OnDeactivate {
-
-     onDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
-  }
-
-
-  /**
-   * Defines route lifecycle method [onReuse], which is called by the router at the end of a
-   * successful route navigation when [canReuse] is implemented and returns or resolves to true.
-   *
-   * For a single component's navigation, only one of either [onActivate] or [onReuse] will be called,
-   * depending on the result of [canReuse].
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'my-cmp'
-   * })
-   * class MyCmp implements CanReuse, OnReuse {
-   *   canReuse() {
-   *     return true;
-   *   }
-   *
-   *   onReuse(next, prev) {
-   *     this.params = next.params;
-   *   }
-   * }
-   *  ```
-   */
-  interface OnReuse {
-
-     onReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
-  }
-
-
-  /**
-   * Defines route lifecycle method [canDeactivate], which is called by the router to determine
-   * if a component can be removed as part of a navigation.
-   *
-   * If `canDeactivate` returns or resolves to `false`, the navigation is cancelled.
-   *
-   * If `canDeactivate` throws or rejects, the navigation is also cancelled.
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'my-cmp'
-   * })
-   * class MyCmp implements CanDeactivate {
-   *   canDeactivate(next, prev) {
-   *     return askUserIfTheyAreSureTheyWantToQuit();
-   *   }
-   * }
-   *  ```
-   */
-  interface CanDeactivate {
-
-     canDeactivate(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
-  }
-
-
-  /**
-   * Defines route lifecycle method [canReuse], which is called by the router to determine whether a
-   * component should be reused across routes, or whether to destroy and instantiate a new component.
-   *
-   * If `canReuse` returns or resolves to `true`, the component instance will be reused.
-   *
-   * If `canReuse` throws or rejects, the navigation will be cancelled.
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'my-cmp'
-   * })
-   * class MyCmp implements CanReuse, OnReuse {
-   *   canReuse(next, prev) {
-   *     return next.params.id == prev.params.id;
-   *   }
-   *
-   *   onReuse(next, prev) {
-   *     this.id = next.params.id;
-   *   }
-   * }
-   *  ```
-   */
-  interface CanReuse {
-
-     canReuse(nextInstruction: ComponentInstruction, prevInstruction: ComponentInstruction): any;
-  }
-
-
-  /**
-   * Defines route lifecycle method [canActivate], which is called by the router to determine
-   * if a component can be instantiated as part of a navigation.
-   *
-   * Note that unlike other lifecycle hooks, this one uses an annotation rather than an interface.
-   * This is because [canActivate] is called before the component is instantiated.
-   *
-   * If `canActivate` returns or resolves to `false`, the navigation is cancelled.
-   *
-   * If `canActivate` throws or rejects, the navigation is also cancelled.
-   *
-   * ## Example
-   * ```
-   * @Directive({
-   *   selector: 'control-panel-cmp'
-   * })
-   * @CanActivate(() => checkIfUserIsLoggedIn())
-   * class ControlPanelCmp {
-   *   // ...
-   * }
-   *  ```
-   */
-  var CanActivate : (hook: (next: ComponentInstruction, prev: ComponentInstruction) => Promise<boolean>| boolean) =>
-        ClassDecorator ;
-
-
-  /**
-   * `Instruction` is a tree of `ComponentInstructions`, with all the information needed
-   * to transition each component in the app to a given route, including all auxiliary routes.
-   *
-   * This is a public API.
-   */
-  class Instruction {
-
-     component: ComponentInstruction;
-
-     child: Instruction;
-
-     auxInstruction: StringMap<string, Instruction>;
-
-     replaceChild(child: Instruction): Instruction;
-  }
-
-
-  /**
-   * A `ComponentInstruction` represents the route state for a single component. An `Instruction` is
-   * composed of a tree of these `ComponentInstruction`s.
-   *
-   * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
-   * to route lifecycle hooks, like {@link CanActivate}.
-   *
-   * `ComponentInstruction`s are [https://en.wikipedia.org/wiki/Hash_consing](hash consed). You should
-   * never construct one yourself with "new." Instead, rely on {@link PathRecognizer} to construct
-   * `ComponentInstruction`s.
-   *
-   * You should not modify this object. It should be treated as immutable.
-   */
-  class ComponentInstruction {
-
-     reuse: boolean;
-
-     urlPath: string;
-
-     urlParams: string[];
-
-     params: StringMap<string, any>;
-
-     componentType: any;
-
-     resolveComponentType(): Promise<ng.Type>;
-
-     specificity: any;
-
-     terminal: any;
-
-     routeData(): Object;
-  }
-
-
-  /**
-   * This class represents a parsed URL
-   */
-  class Url {
-
-     path: string;
-
-     child: Url;
-
-     auxiliary: Url[];
-
-     params: StringMap<string, any>;
-
-     toString(): string;
-
-     segmentToString(): string;
-  }
-
-  class OpaqueToken {
-
-     toString(): string;
-  }
-
-  const ROUTE_DATA : OpaqueToken ;
-
-  const ROUTER_DIRECTIVES : any[] ;
-
-  const ROUTER_BINDINGS : any[] ;
-
-  class Route implements RouteDefinition {
-
-     data: any;
-
-     path: string;
-
-     component: ng.Type;
-
-     as: string;
-
-     loader: Function;
-
-     redirectTo: string;
-  }
-
-  class Redirect implements RouteDefinition {
-
-     path: string;
-
-     redirectTo: string;
-
-     as: string;
-
-     loader: Function;
-
-     data: any;
-  }
-
-  class AuxRoute implements RouteDefinition {
-
-     data: any;
-
-     path: string;
-
-     component: ng.Type;
-
-     as: string;
-
-     loader: Function;
-
-     redirectTo: string;
-  }
-
-  class AsyncRoute implements RouteDefinition {
-
-     data: any;
-
-     path: string;
-
-     loader: Function;
-
-     as: string;
-  }
-
-  interface RouteDefinition {
-
-     path: string;
-
-     component?: ng.Type | ComponentDefinition;
-
-     loader?: Function;
-
-     redirectTo?: string;
-
-     as?: string;
-
-     data?: any;
-  }
-
-  var RouteConfig : (configs: RouteDefinition[]) => ClassDecorator ;
-
-  interface ComponentDefinition {
-
-     type: string;
-
-     loader?: Function;
-
-     component?: ng.Type;
-  }
-
-}
-
-declare module "angular2/router" {
-  export = ngRouter;
-}
-
-

angular2/test_lib-2.0.0-alpha.38.d.ts

@@ -0,0 +1,408 @@
+// Type definitions for Angular v2.0.0-local_sha.f77234e
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/test_lib depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="./angular2-2.0.0-alpha.38.d.ts"/>
+///<reference path="../jasmine/jasmine.d.ts"/>
+
+
+
+declare module ngTestLib {  
+  /**
+   * Allows injecting dependencies in `beforeEach()` and `it()`.
+   * 
+   * Example:
+   * 
+   * ```
+   * beforeEach(inject([Dependency, AClass], (dep, object) => {
+   *   // some code that uses `dep` and `object`
+   *   // ...
+   * }));
+   * 
+   * it('...', inject([AClass, AsyncTestCompleter], (object, async) => {
+   *   object.doSomething().then(() => {
+   *     expect(...);
+   *     async.done();
+   *   });
+   * })
+   * ```
+   * 
+   * Notes:
+   * - injecting an `AsyncTestCompleter` allow completing async tests - this is the equivalent of
+   *   adding a `done` parameter in Jasmine,
+   * - inject is currently a function because of some Traceur limitation the syntax should eventually
+   *   becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`
+   * 
+   * @param {Array} tokens
+   * @param {Function} fn
+   * @return {FunctionWithParamTokens}
+   */
+  function inject(tokens: any[], fn: Function): FunctionWithParamTokens;
+  
+
+    
+  var proxy: ClassDecorator;
+  
+
+    
+  var afterEach: Function;
+  
+
+    
+  type SyncTestFn = () => void
+
+    
+  interface NgMatchers extends jasmine.Matchers {
+    
+    toBe(expected: any): boolean;
+    
+    toEqual(expected: any): boolean;
+    
+    toBePromise(): boolean;
+    
+    toBeAnInstanceOf(expected: any): boolean;
+    
+    toHaveText(expected: any): boolean;
+    
+    toHaveCssClass(expected: any): boolean;
+    
+    toImplement(expected: any): boolean;
+    
+    toContainError(expected: any): boolean;
+    
+    toThrowErrorWith(expectedMessage: any): boolean;
+    
+    not: NgMatchers;
+    
+  }
+
+    
+  var expect: (actual: any) => NgMatchers;
+  
+
+    
+  class AsyncTestCompleter {
+    
+    constructor(_done: Function);
+    
+    done(): void;
+    
+  }
+
+    
+  function describe(...args: any[]): void;
+  
+
+    
+  function ddescribe(...args: any[]): void;
+  
+
+    
+  function xdescribe(...args: any[]): void;
+  
+
+    
+  function beforeEach(fn: FunctionWithParamTokens | SyncTestFn): void;
+  
+
+    
+  /**
+   * Allows overriding default bindings defined in test_injector.js.
+   * 
+   * The given function must return a list of DI bindings.
+   * 
+   * Example:
+   * 
+   *   beforeEachBindings(() => [
+   *     bind(Compiler).toClass(MockCompiler),
+   *     bind(SomeToken).toValue(myValue),
+   *   ]);
+   */
+  function beforeEachBindings(fn: any): void;
+  
+
+    
+  function it(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  function xit(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  function iit(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  interface GuinessCompatibleSpy extends jasmine.Spy {
+    
+    /**
+     * By chaining the spy with and.returnValue, all calls to the function will return a specific
+     * value.
+     */
+    andReturn(val: any): void;
+    
+    /**
+     * By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied
+     * function.
+     */
+    andCallFake(fn: Function): GuinessCompatibleSpy;
+    
+    /**
+     * removes all recorded calls
+     */
+    reset(): void;
+    
+  }
+
+    
+  class SpyObject {
+    
+    constructor(type?: any);
+    
+    static stub(object?: any, config?: any, overrides?: any): void;
+    
+    noSuchMethod(args: any): void;
+    
+    spy(name: any): void;
+    
+    prop(name: any, value: any): void;
+    
+  }
+
+    
+  function isInInnerZone(): boolean;
+  
+
+    
+  interface RootTestComponent {
+    
+    debugElement: ng.DebugElement;
+    
+    detectChanges(): void;
+    
+    destroy(): void;
+    
+  }
+
+    
+  /**
+   * Builds a RootTestComponent for use in component level tests.
+   */
+  class TestComponentBuilder {
+    
+    constructor(_injector: ng.Injector);
+    
+    /**
+     * Overrides only the html of a {@link ComponentMetadata}.
+     * All the other properties of the component's {@link ng.ViewMetadata} are preserved.
+     * 
+     * @param {ng.Type} component
+     * @param {string} html
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideTemplate(componentType: ng.Type, template: string): TestComponentBuilder;
+    
+    /**
+     * Overrides a component's {@link ng.ViewMetadata}.
+     * 
+     * @param {ng.Type} component
+     * @param {view} View
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideView(componentType: ng.Type, view: ng.ViewMetadata): TestComponentBuilder;
+    
+    /**
+     * Overrides the directives from the component {@link ng.ViewMetadata}.
+     * 
+     * @param {ng.Type} component
+     * @param {ng.Type} from
+     * @param {ng.Type} to
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideDirective(componentType: ng.Type, from: ng.Type, to: ng.Type): TestComponentBuilder;
+    
+    /**
+     * Overrides one or more injectables configured via `bindings` metadata property of a directive or
+     * component.
+     * Very useful when certain bindings need to be mocked out.
+     * 
+     * The bindings specified via this method are appended to the existing `bindings` causing the
+     * duplicated bindings to
+     * be overridden.
+     * 
+     * @param {ng.Type} component
+     * @param {any[]} bindings
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideBindings(type: ng.Type, bindings: any[]): TestComponentBuilder;
+    
+    /**
+     * Overrides one or more injectables configured via `bindings` metadata property of a directive or
+     * component.
+     * Very useful when certain bindings need to be mocked out.
+     * 
+     * The bindings specified via this method are appended to the existing `bindings` causing the
+     * duplicated bindings to
+     * be overridden.
+     * 
+     * @param {ng.Type} component
+     * @param {any[]} bindings
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideViewBindings(type: ng.Type, bindings: any[]): TestComponentBuilder;
+    
+    /**
+     * Builds and returns a RootTestComponent.
+     * 
+     * @return {Promise<RootTestComponent>}
+     */
+    createAsync(rootComponentType: ng.Type): Promise<RootTestComponent>;
+    
+  }
+
+    
+  function createTestInjector(bindings: Array<ng.Type | ng.Binding | any[]>): ng.Injector;
+  
+
+    
+  class FunctionWithParamTokens {
+    
+    constructor(_tokens: any[], _fn: Function);
+    
+    /**
+     * Returns the value of the executed function.
+     */
+    execute(injector: ng.Injector): any;
+    
+    hasToken(token: any): boolean;
+    
+  }
+
+    
+  /**
+   * Wraps a function to be executed in the fakeAsync zone:
+   * - microtasks are manually executed by calling `flushMicrotasks()`,
+   * - timers are synchronous, `tick()` simulates the asynchronous passage of time.
+   * 
+   * If there are any pending timers at the end of the function, an exception will be thrown.
+   * 
+   * @param fn
+   * @returns {Function} The function wrapped to be executed in the fakeAsync zone
+   */
+  function fakeAsync(fn: Function): Function;
+  
+
+    
+  function clearPendingTimers(): void;
+  
+
+    
+  /**
+   * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.
+   * 
+   * The microtasks queue is drained at the very start of this function and after any timer callback
+   * has been executed.
+   * 
+   * @param {number} millis Number of millisecond, defaults to 0
+   */
+  function tick(millis?: number): void;
+  
+
+    
+  /**
+   * Flush any pending microtasks.
+   */
+  function flushMicrotasks(): void;
+  
+
+    
+  class Log {
+    
+    constructor();
+    
+    add(value: any): void;
+    
+    fn(value: any): void;
+    
+    clear(): void;
+    
+    result(): string;
+    
+  }
+
+    
+  class BrowserDetection {
+    
+    constructor(ua: string);
+    
+    isFirefox: boolean;
+    
+    isAndroid: boolean;
+    
+    isEdge: boolean;
+    
+    isIE: boolean;
+    
+    isWebkit: boolean;
+    
+    isIOS7: boolean;
+    
+    isSlow: boolean;
+    
+    supportsIntlApi: boolean;
+    
+  }
+
+    
+  var browserDetection: BrowserDetection;
+  
+
+    
+  function dispatchEvent(element: any, eventType: any): void;
+  
+
+    
+  function el(html: string): HTMLElement;
+  
+
+    
+  function containsRegexp(input: string): RegExp;
+  
+
+    
+  function normalizeCSS(css: string): string;
+  
+
+    
+  function stringifyElement(el: any): string;
+  
+
+    
+  var RootTestComponent: ng.InjectableReference;
+  
+
+  
+}
+
+declare module "angular2/test_lib" {
+  export = ngTestLib;
+}
+
+

angular2/test_lib-2.0.0-alpha.39.d.ts

@@ -0,0 +1,408 @@
+// Type definitions for Angular v2.0.0-local_sha.7d5c3eb
+// Project: http://angular.io/
+// Definitions by: angular team <https://github.com/angular/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// ***********************************************************
+// This file is generated by the Angular build process.
+// Please do not create manual edits or send pull requests
+// modifying this file.
+// ***********************************************************
+
+// angular2/test_lib depends transitively on these libraries.
+// If you don't have them installed you can install them using TSD
+// https://github.com/DefinitelyTyped/tsd
+
+///<reference path="./angular2-2.0.0-alpha.39.d.ts"/>
+///<reference path="../jasmine/jasmine.d.ts"/>
+
+
+
+declare module ngTestLib {  
+  /**
+   * Allows injecting dependencies in `beforeEach()` and `it()`.
+   * 
+   * Example:
+   * 
+   * ```
+   * beforeEach(inject([Dependency, AClass], (dep, object) => {
+   *   // some code that uses `dep` and `object`
+   *   // ...
+   * }));
+   * 
+   * it('...', inject([AClass, AsyncTestCompleter], (object, async) => {
+   *   object.doSomething().then(() => {
+   *     expect(...);
+   *     async.done();
+   *   });
+   * })
+   * ```
+   * 
+   * Notes:
+   * - injecting an `AsyncTestCompleter` allow completing async tests - this is the equivalent of
+   *   adding a `done` parameter in Jasmine,
+   * - inject is currently a function because of some Traceur limitation the syntax should eventually
+   *   becomes `it('...', @Inject (object: AClass, async: AsyncTestCompleter) => { ... });`
+   * 
+   * @param {Array} tokens
+   * @param {Function} fn
+   * @return {FunctionWithParamTokens}
+   */
+  function inject(tokens: any[], fn: Function): FunctionWithParamTokens;
+  
+
+    
+  var proxy: ClassDecorator;
+  
+
+    
+  var afterEach: Function;
+  
+
+    
+  type SyncTestFn = () => void
+
+    
+  interface NgMatchers extends jasmine.Matchers {
+    
+    toBe(expected: any): boolean;
+    
+    toEqual(expected: any): boolean;
+    
+    toBePromise(): boolean;
+    
+    toBeAnInstanceOf(expected: any): boolean;
+    
+    toHaveText(expected: any): boolean;
+    
+    toHaveCssClass(expected: any): boolean;
+    
+    toImplement(expected: any): boolean;
+    
+    toContainError(expected: any): boolean;
+    
+    toThrowErrorWith(expectedMessage: any): boolean;
+    
+    not: NgMatchers;
+    
+  }
+
+    
+  var expect: (actual: any) => NgMatchers;
+  
+
+    
+  class AsyncTestCompleter {
+    
+    constructor(_done: Function);
+    
+    done(): void;
+    
+  }
+
+    
+  function describe(...args: any[]): void;
+  
+
+    
+  function ddescribe(...args: any[]): void;
+  
+
+    
+  function xdescribe(...args: any[]): void;
+  
+
+    
+  function beforeEach(fn: FunctionWithParamTokens | SyncTestFn): void;
+  
+
+    
+  /**
+   * Allows overriding default bindings defined in test_injector.js.
+   * 
+   * The given function must return a list of DI bindings.
+   * 
+   * Example:
+   * 
+   *   beforeEachBindings(() => [
+   *     bind(Compiler).toClass(MockCompiler),
+   *     bind(SomeToken).toValue(myValue),
+   *   ]);
+   */
+  function beforeEachBindings(fn: any): void;
+  
+
+    
+  function it(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  function xit(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  function iit(name: any, fn: any, timeOut?: any): void;
+  
+
+    
+  interface GuinessCompatibleSpy extends jasmine.Spy {
+    
+    /**
+     * By chaining the spy with and.returnValue, all calls to the function will return a specific
+     * value.
+     */
+    andReturn(val: any): void;
+    
+    /**
+     * By chaining the spy with and.callFake, all calls to the spy will delegate to the supplied
+     * function.
+     */
+    andCallFake(fn: Function): GuinessCompatibleSpy;
+    
+    /**
+     * removes all recorded calls
+     */
+    reset(): void;
+    
+  }
+
+    
+  class SpyObject {
+    
+    constructor(type?: any);
+    
+    static stub(object?: any, config?: any, overrides?: any): void;
+    
+    noSuchMethod(args: any): void;
+    
+    spy(name: any): void;
+    
+    prop(name: any, value: any): void;
+    
+  }
+
+    
+  function isInInnerZone(): boolean;
+  
+
+    
+  interface RootTestComponent {
+    
+    debugElement: ng.DebugElement;
+    
+    detectChanges(): void;
+    
+    destroy(): void;
+    
+  }
+
+    
+  /**
+   * Builds a RootTestComponent for use in component level tests.
+   */
+  class TestComponentBuilder {
+    
+    constructor(_injector: ng.Injector);
+    
+    /**
+     * Overrides only the html of a {@link ComponentMetadata}.
+     * All the other properties of the component's {@link ng.ViewMetadata} are preserved.
+     * 
+     * @param {ng.Type} component
+     * @param {string} html
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideTemplate(componentType: ng.Type, template: string): TestComponentBuilder;
+    
+    /**
+     * Overrides a component's {@link ng.ViewMetadata}.
+     * 
+     * @param {ng.Type} component
+     * @param {view} View
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideView(componentType: ng.Type, view: ng.ViewMetadata): TestComponentBuilder;
+    
+    /**
+     * Overrides the directives from the component {@link ng.ViewMetadata}.
+     * 
+     * @param {ng.Type} component
+     * @param {ng.Type} from
+     * @param {ng.Type} to
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideDirective(componentType: ng.Type, from: ng.Type, to: ng.Type): TestComponentBuilder;
+    
+    /**
+     * Overrides one or more injectables configured via `bindings` metadata property of a directive or
+     * component.
+     * Very useful when certain bindings need to be mocked out.
+     * 
+     * The bindings specified via this method are appended to the existing `bindings` causing the
+     * duplicated bindings to
+     * be overridden.
+     * 
+     * @param {ng.Type} component
+     * @param {any[]} bindings
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideBindings(type: ng.Type, bindings: any[]): TestComponentBuilder;
+    
+    /**
+     * Overrides one or more injectables configured via `bindings` metadata property of a directive or
+     * component.
+     * Very useful when certain bindings need to be mocked out.
+     * 
+     * The bindings specified via this method are appended to the existing `bindings` causing the
+     * duplicated bindings to
+     * be overridden.
+     * 
+     * @param {ng.Type} component
+     * @param {any[]} bindings
+     * 
+     * @return {TestComponentBuilder}
+     */
+    overrideViewBindings(type: ng.Type, bindings: any[]): TestComponentBuilder;
+    
+    /**
+     * Builds and returns a RootTestComponent.
+     * 
+     * @return {Promise<RootTestComponent>}
+     */
+    createAsync(rootComponentType: ng.Type): Promise<RootTestComponent>;
+    
+  }
+
+    
+  function createTestInjector(bindings: Array<ng.Type | ng.Binding | any[]>): ng.Injector;
+  
+
+    
+  class FunctionWithParamTokens {
+    
+    constructor(_tokens: any[], _fn: Function);
+    
+    /**
+     * Returns the value of the executed function.
+     */
+    execute(injector: ng.Injector): any;
+    
+    hasToken(token: any): boolean;
+    
+  }
+
+    
+  /**
+   * Wraps a function to be executed in the fakeAsync zone:
+   * - microtasks are manually executed by calling `flushMicrotasks()`,
+   * - timers are synchronous, `tick()` simulates the asynchronous passage of time.
+   * 
+   * If there are any pending timers at the end of the function, an exception will be thrown.
+   * 
+   * @param fn
+   * @returns {Function} The function wrapped to be executed in the fakeAsync zone
+   */
+  function fakeAsync(fn: Function): Function;
+  
+
+    
+  function clearPendingTimers(): void;
+  
+
+    
+  /**
+   * Simulates the asynchronous passage of time for the timers in the fakeAsync zone.
+   * 
+   * The microtasks queue is drained at the very start of this function and after any timer callback
+   * has been executed.
+   * 
+   * @param {number} millis Number of millisecond, defaults to 0
+   */
+  function tick(millis?: number): void;
+  
+
+    
+  /**
+   * Flush any pending microtasks.
+   */
+  function flushMicrotasks(): void;
+  
+
+    
+  class Log {
+    
+    constructor();
+    
+    add(value: any): void;
+    
+    fn(value: any): void;
+    
+    clear(): void;
+    
+    result(): string;
+    
+  }
+
+    
+  class BrowserDetection {
+    
+    constructor(ua: string);
+    
+    isFirefox: boolean;
+    
+    isAndroid: boolean;
+    
+    isEdge: boolean;
+    
+    isIE: boolean;
+    
+    isWebkit: boolean;
+    
+    isIOS7: boolean;
+    
+    isSlow: boolean;
+    
+    supportsIntlApi: boolean;
+    
+  }
+
+    
+  var browserDetection: BrowserDetection;
+  
+
+    
+  function dispatchEvent(element: any, eventType: any): void;
+  
+
+    
+  function el(html: string): HTMLElement;
+  
+
+    
+  function containsRegexp(input: string): RegExp;
+  
+
+    
+  function normalizeCSS(css: string): string;
+  
+
+    
+  function stringifyElement(el: any): string;
+  
+
+    
+  var RootTestComponent: ng.InjectableReference;
+  
+
+  
+}
+
+declare module "angular2/test_lib" {
+  export = ngTestLib;
+}
+
+

angularjs/README.md

@@ -42,7 +42,7 @@ To avoid cluttering the list of suggestions as you type in your IDE, all interfa
 
 **ngMockE2E** does not define a new namespace, but rather modifies some of **ng**'s interfaces.
 
-Bellow is an example of how to use the interfaces:
+Below is an example of how to use the interfaces:
 ```ts
 function MainController($scope: ng.IScope, $http: ng.IHttpService) {
     // code assistance will now be available for $scope and $http

angularjs/angular-animate.d.ts

@@ -121,7 +121,7 @@ declare module angular.animate {
     }
 
     /**
-     * AngularProvider
+     * AnimateProvider
      * see http://docs.angularjs.org/api/ngAnimate/provider/$animateProvider
      */
     interface IAnimateProvider {

angularjs/angular-component-router.d.ts

@@ -0,0 +1,429 @@
+// Type definitions for Angular JS 1.5 component router
+// Project: http://angularjs.org
+// Definitions by: David Reher <http://github.com/davidreher>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="./angular.d.ts" />
+/// <reference path="../es6-promise/es6-promise.d.ts" />
+
+declare module angular {
+    /**
+     * `Instruction` is a tree of {@link ComponentInstruction}s with all the information needed
+     * to transition each component in the app to a given route, including all auxiliary routes.
+     *
+     * `Instruction`s can be created using {@link Router#generate}, and can be used to
+     * perform route changes with {@link Router#navigateByInstruction}.
+     *
+     * ### Example
+     *
+     * ```
+     * import {Component} from 'angular2/core';
+     * import {bootstrap} from 'angular2/platform/browser';
+     * import {Router, ROUTER_DIRECTIVES, ROUTER_PROVIDERS, RouteConfig} from 'angular2/router';
+     *
+     * @Component({directives: [ROUTER_DIRECTIVES]})
+     * @RouteConfig([
+     *  {...},
+     * ])
+     * class AppCmp {
+     *   constructor(router: Router) {
+     *     var instruction = router.generate(['/MyRoute']);
+     *     router.navigateByInstruction(instruction);
+     *   }
+     * }
+     *
+     * bootstrap(AppCmp, ROUTER_PROVIDERS);
+     * ```
+     */
+    interface Instruction {
+
+        urlPath(): string;
+
+        urlParams(): string[];
+
+        specificity(): number;
+
+        resolveComponent(): Promise<ComponentInstruction>;
+
+        /**
+         * converts the instruction into a URL string
+         */
+        toRootUrl(): string;
+
+        toUrlQuery(): string;
+
+        /**
+         * Returns a new instruction that shares the state of the existing instruction, but with
+         * the given child {@link Instruction} replacing the existing child.
+         */
+        replaceChild(child: Instruction): Instruction;
+
+        /**
+         * If the final URL for the instruction is ``
+         */
+        toUrlPath(): string;
+
+        /**
+         * default instructions override these
+         */
+        toLinkUrl(): string;
+    }
+
+    /**
+     * A router outlet is a placeholder that Angular dynamically fills based on the application's route.
+     *
+     * ## Use
+     *
+     * ```
+     * <router-outlet></router-outlet>
+     * ```
+     */
+    interface RouterOutlet {
+        name: string;
+
+        /**
+         * Called by the Router to instantiate a new component during the commit phase of a navigation.
+         * This method in turn is responsible for calling the `routerOnActivate` hook of its child.
+         */
+        activate(nextInstruction: ComponentInstruction): Promise<any>;
+
+        /**
+         * Called by the {@link Router} during the commit phase of a navigation when an outlet
+         * reuses a component between different routes.
+         * This method in turn is responsible for calling the `routerOnReuse` hook of its child.
+         */
+        reuse(nextInstruction: ComponentInstruction): Promise<any>;
+
+        /**
+         * Called by the {@link Router} when an outlet disposes of a component's contents.
+         * This method in turn is responsible for calling the `routerOnDeactivate` hook of its child.
+         */
+        deactivate(nextInstruction: ComponentInstruction): Promise<any>;
+
+        /**
+         * Called by the {@link Router} during recognition phase of a navigation.
+         *
+         * If this resolves to `false`, the given navigation is cancelled.
+         *
+         * This method delegates to the child component's `routerCanDeactivate` hook if it exists,
+         * and otherwise resolves to true.
+         */
+        routerCanDeactivate(nextInstruction: ComponentInstruction): Promise<boolean>;
+
+        /**
+         * Called by the {@link Router} during recognition phase of a navigation.
+         *
+         * If the new child component has a different Type than the existing child component,
+         * this will resolve to `false`. You can't reuse an old component when the new component
+         * is of a different Type.
+         *
+         * Otherwise, this method delegates to the child component's `routerCanReuse` hook if it exists,
+         * or resolves to true if the hook is not present.
+         */
+        routerCanReuse(nextInstruction: ComponentInstruction): Promise<boolean>;
+    }
+
+    interface RouteRegistry {
+        /**
+         * Given a component and a configuration object, add the route to this registry
+         */
+        config(parentComponent: any, config: RouteDefinition): void;
+
+        /**
+         * Reads the annotations of a component and configures the registry based on them
+         */
+        configFromComponent(component: any): void;
+
+        /**
+         * Given a URL and a parent component, return the most specific instruction for navigating
+         * the application into the state specified by the url
+         */
+        recognize(url: string, ancestorInstructions: Instruction[]): Promise<Instruction>;
+
+        /**
+         * Given a normalized list with component names and params like: `['user', {id: 3 }]`
+         * generates a url with a leading slash relative to the provided `parentComponent`.
+         *
+         * If the optional param `_aux` is `true`, then we generate starting at an auxiliary
+         * route boundary.
+         */
+        generate(linkParams: any[], ancestorInstructions: Instruction[], _aux?: boolean): Instruction;
+
+        hasRoute(name: string, parentComponent: any): boolean;
+
+        generateDefault(componentCursor: any): Instruction;
+    }
+
+    /**
+     * The `Router` is responsible for mapping URLs to components.
+     *
+     * You can see the state of the router by inspecting the read-only field `router.navigating`.
+     * This may be useful for showing a spinner, for instance.
+     *
+     * ## Concepts
+     *
+     * Routers and component instances have a 1:1 correspondence.
+     *
+     * The router holds reference to a number of {@link RouterOutlet}.
+     * An outlet is a placeholder that the router dynamically fills in depending on the current URL.
+     *
+     * When the router navigates from a URL, it must first recognize it and serialize it into an
+     * `Instruction`.
+     * The router uses the `RouteRegistry` to get an `Instruction`.
+     */
+    interface Router {
+        navigating: boolean;
+        lastNavigationAttempt: string;
+        registry: RouteRegistry;
+        parent: Router;
+        hostComponent: any;
+
+        /**
+         * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+         * component.
+         */
+        childRouter(hostComponent: any): Router;
+
+        /**
+         * Constructs a child router. You probably don't need to use this unless you're writing a reusable
+         * component.
+         */
+        auxRouter(hostComponent: any): Router;
+
+        /**
+         * Register an outlet to be notified of primary route changes.
+         *
+         * You probably don't need to use this unless you're writing a reusable component.
+         */
+        registerPrimaryOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+        /**
+         * Register an outlet to notified of auxiliary route changes.
+         *
+         * You probably don't need to use this unless you're writing a reusable component.
+         */
+        registerAuxOutlet(outlet: RouterOutlet): Promise<boolean>;
+
+        /**
+         * Given an instruction, returns `true` if the instruction is currently active,
+         * otherwise `false`.
+         */
+        isRouteActive(instruction: Instruction): boolean;
+
+        /**
+         * Dynamically update the routing configuration and trigger a navigation.
+         *
+         * ### Usage
+         *
+         * ```
+         * router.config([
+         *   { 'path': '/', 'component': IndexComp },
+         *   { 'path': '/user/:id', 'component': UserComp },
+         * ]);
+         * ```
+         */
+        config(definitions: RouteDefinition[]): Promise<any>;
+
+        /**
+         * Navigate based on the provided Route Link DSL. It's preferred to navigate with this method
+         * over `navigateByUrl`.
+         *
+         * ### Usage
+         *
+         * This method takes an array representing the Route Link DSL:
+         * ```
+         * ['./MyCmp', {param: 3}]
+         * ```
+         * See the {@link RouterLink} directive for more.
+         */
+        navigate(linkParams: any[]): Promise<any>;
+
+        /**
+         * Navigate to a URL. Returns a promise that resolves when navigation is complete.
+         * It's preferred to navigate with `navigate` instead of this method, since URLs are more brittle.
+         *
+         * If the given URL begins with a `/`, router will navigate absolutely.
+         * If the given URL does not begin with `/`, the router will navigate relative to this component.
+         */
+        navigateByUrl(url: string, _skipLocationChange?: boolean): Promise<any>;
+
+        /**
+         * Navigate via the provided instruction. Returns a promise that resolves when navigation is
+         * complete.
+         */
+        navigateByInstruction(instruction: Instruction,
+                              _skipLocationChange?: boolean): Promise<any>;
+
+        /**
+         * Updates this router and all descendant routers according to the given instruction
+         */
+        commit(instruction: Instruction, _skipLocationChange?: boolean): Promise<any>;
+
+        /**
+         * Subscribe to URL updates from the router
+         */
+        subscribe(onNext: (value: any) => void): Object;
+
+        /**
+         * Removes the contents of this router's outlet and all descendant outlets
+         */
+        deactivate(instruction: Instruction): Promise<any>;
+
+        /**
+         * Given a URL, returns an instruction representing the component graph
+         */
+        recognize(url: string): Promise<Instruction>;
+
+        /**
+         * Navigates to either the last URL successfully navigated to, or the last URL requested if the
+         * router has yet to successfully navigate.
+         */
+        renavigate(): Promise<any>;
+
+        /**
+         * Generate an `Instruction` based on the provided Route Link DSL.
+         */
+        generate(linkParams: any[]): Instruction;
+    }
+
+    /**
+     * RouteData is an immutable map of additional data you can configure in your Route.
+     * You can inject RouteData into the constructor of a component to use it.
+     */
+    interface RouteData {
+        data: {[key: string]: any};
+        get(key: string): any;
+    }
+
+    /**
+     * A `ComponentInstruction` represents the route state for a single component. An `Instruction` is
+     * composed of a tree of these `ComponentInstruction`s.
+     *
+     * `ComponentInstructions` is a public API. Instances of `ComponentInstruction` are passed
+     * to route lifecycle hooks, like {@link CanActivate}.
+     *
+     * `ComponentInstruction`s are [https://en.wikipedia.org/wiki/Hash_consing](hash consed). You should
+     * never construct one yourself with "new." Instead, rely on {@link Router/RouteRecognizer} to
+     * construct `ComponentInstruction`s.
+     *
+     * You should not modify this object. It should be treated as immutable.
+     */
+    interface ComponentInstruction {
+        reuse: boolean;
+        routeData: RouteData;
+        urlPath: string;
+        urlParams: string[];
+        data: RouteData;
+        componentType: any;
+        terminal: boolean;
+        specificity: number;
+        params: {[key: string]: any};
+    }
+
+    /**
+     * Defines route lifecycle method `routerOnActivate`, which is called by the router at the end of a
+     * successful route navigation.
+     *
+     * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
+     * will be called depending on the result of {@link CanReuse}.
+     *
+     * The `routerOnActivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+     * first
+     * representing the current route being navigated to, and the second parameter representing the
+     * previous route or `null`.
+     *
+     * If `routerOnActivate` returns a promise, the route change will wait until the promise settles to
+     * instantiate and activate child components.
+     *
+     * ### Example
+     * {@example router/ts/on_activate/on_activate_example.ts region='routerOnActivate'}
+     */
+    interface OnActivate {
+        $routerOnActivate(next?: angular.ComponentInstruction, prev?: angular.ComponentInstruction): any;
+    }
+
+    /**
+     * Defines route lifecycle method `routerCanDeactivate`, which is called by the router to determine
+     * if a component can be removed as part of a navigation.
+     *
+     * The `routerCanDeactivate` hook is called with two {@link ComponentInstruction}s as parameters,
+     * the
+     * first representing the current route being navigated to, and the second parameter
+     * representing the previous route.
+     *
+     * If `routerCanDeactivate` returns or resolves to `false`, the navigation is cancelled. If it
+     * returns or
+     * resolves to `true`, then the navigation continues, and the component will be deactivated
+     * (the {@link OnDeactivate} hook will be run) and removed.
+     *
+     * If `routerCanDeactivate` throws or rejects, the navigation is also cancelled.
+     *
+     * ### Example
+     * {@example router/ts/can_deactivate/can_deactivate_example.ts region='routerCanDeactivate'}
+     */
+    interface CanDeactivate {
+        $routerCanDeactivate(next?: ComponentInstruction, prev?: ComponentInstruction): boolean | Promise<boolean>;
+    }
+
+    /**
+     * Defines route lifecycle method `routerOnDeactivate`, which is called by the router before
+     * destroying
+     * a component as part of a route change.
+     *
+     * The `routerOnDeactivate` hook is called with two {@link ComponentInstruction}s as parameters, the
+     * first
+     * representing the current route being navigated to, and the second parameter representing the
+     * previous route.
+     *
+     * If `routerOnDeactivate` returns a promise, the route change will wait until the promise settles.
+     *
+     * ### Example
+     * {@example router/ts/on_deactivate/on_deactivate_example.ts region='routerOnDeactivate'}
+     */
+    interface OnDeactivate {
+        $routerOnDeactivate(next?: angular.ComponentInstruction, prev?: angular.ComponentInstruction): any;
+    }
+
+    /**
+     * Defines route lifecycle method `routerCanReuse`, which is called by the router to determine
+     * whether a
+     * component should be reused across routes, or whether to destroy and instantiate a new component.
+     *
+     * The `routerCanReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+     * first
+     * representing the current route being navigated to, and the second parameter representing the
+     * previous route.
+     *
+     * If `routerCanReuse` returns or resolves to `true`, the component instance will be reused and the
+     * {@link OnDeactivate} hook will be run. If `routerCanReuse` returns or resolves to `false`, a new
+     * component will be instantiated, and the existing component will be deactivated and removed as
+     * part of the navigation.
+     *
+     * If `routerCanReuse` throws or rejects, the navigation will be cancelled.
+     *
+     * ### Example
+     * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
+     */
+    interface CanReuse {
+        $routerCanReuse(next?: angular.ComponentInstruction, prev?: angular.ComponentInstruction): boolean | Promise<boolean>;
+    }
+
+    /**
+     * Defines route lifecycle method `routerOnReuse`, which is called by the router at the end of a
+     * successful route navigation when {@link CanReuse} is implemented and returns or resolves to true.
+     *
+     * For a single component's navigation, only one of either {@link OnActivate} or {@link OnReuse}
+     * will be called, depending on the result of {@link CanReuse}.
+     *
+     * The `routerOnReuse` hook is called with two {@link ComponentInstruction}s as parameters, the
+     * first
+     * representing the current route being navigated to, and the second parameter representing the
+     * previous route or `null`.
+     *
+     * ### Example
+     * {@example router/ts/reuse/reuse_example.ts region='reuseCmp'}
+     */
+    interface OnReuse {
+        $routerOnReuse(next?: angular.ComponentInstruction, prev?: angular.ComponentInstruction): any;
+    }
+}

angularjs/angular-resource-tests.ts

@@ -8,11 +8,24 @@ interface IMyResourceClass extends angular.resource.IResourceClass<IMyResource>
 ///////////////////////////////////////
 var actionDescriptor: angular.resource.IActionDescriptor;
 
-actionDescriptor.url = '/api/test-url/'
-actionDescriptor.headers = { header: 'value' };
-actionDescriptor.isArray = true;
-actionDescriptor.method = 'method action';
-actionDescriptor.params = { key: 'value' };
+angular.injector(['ng']).invoke(function ($cacheFactory: angular.ICacheFactoryService, $timeout: angular.ITimeoutService) {
+    actionDescriptor.method = 'method action';
+    actionDescriptor.params = { key: 'value' };
+    actionDescriptor.url = '/api/test-url/';
+    actionDescriptor.isArray = true;
+    actionDescriptor.transformRequest = function () { };
+    actionDescriptor.transformRequest = [function () { }];
+    actionDescriptor.transformResponse = function () { };
+    actionDescriptor.transformResponse = [function () { }];
+    actionDescriptor.headers = { header: 'value' };
+    actionDescriptor.cache = true;
+    actionDescriptor.cache = $cacheFactory('cacheId');
+    actionDescriptor.timeout = 1000;
+    actionDescriptor.timeout = $timeout(function () { });
+    actionDescriptor.withCredentials = true;
+    actionDescriptor.responseType = 'response type';
+    actionDescriptor.interceptor = { key: 'value' };
+});
 
 
 ///////////////////////////////////////
@@ -76,6 +89,9 @@ resource = resourceClass.save({ key: 'value' }, { key: 'value' }, function () {
 
 var promise : angular.IPromise<IMyResource>;
 var arrayPromise : angular.IPromise<IMyResource[]>;
+var json: {
+  [index: string]: any;
+};
 
 promise = resource.$delete();
 promise = resource.$delete({ key: 'value' });
@@ -114,6 +130,8 @@ promise = resource.$save(function () { });
 promise = resource.$save(function () { }, function () { });
 promise = resource.$save({ key: 'value' }, function () { }, function () { });
 
+json    = resource.toJSON();
+
 ///////////////////////////////////////
 // IResourceService
 ///////////////////////////////////////

angularjs/angular-resource.d.ts

@@ -5,6 +5,10 @@
 
 /// <reference path="angular.d.ts" />
 
+declare module 'angular-resource' {
+    var _: string;
+    export = _;
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 // ngResource module (angular-resource.js)
@@ -46,11 +50,18 @@ declare module angular.resource {
 
     // Just a reference to facilitate describing new actions
     interface IActionDescriptor {
-        url?: string;
         method: string;
-        isArray?: boolean;
         params?: any;
+        url?: string;
+        isArray?: boolean;
+        transformRequest?: angular.IHttpRequestTransformer | angular.IHttpRequestTransformer[];
+        transformResponse?: angular.IHttpResponseTransformer | angular.IHttpResponseTransformer[];
         headers?: any;
+        cache?: boolean | angular.ICacheObject;
+        timeout?: number | angular.IPromise<any>;
+        withCredentials?: boolean;
+        responseType?: string;
+        interceptor?: any;
     }
 
     // Baseclass for everyresource with default actions.
@@ -129,12 +140,15 @@ declare module angular.resource {
         /** the promise of the original server interaction that created this instance. **/
         $promise : angular.IPromise<T>;
         $resolved : boolean;
+        toJSON: () => {
+          [index: string]: any;
+        }
     }
 
     /**
      * Really just a regular Array object with $promise and $resolve attached to it
      */
-    interface IResourceArray<T> extends Array<T> {
+    interface IResourceArray<T> extends Array<T & IResource<T>> {
         /** the promise of the original server interaction that created this collection. **/
         $promise : angular.IPromise<IResourceArray<T>>;
         $resolved : boolean;

angularjs/angular-route.d.ts

@@ -35,6 +35,16 @@ declare module angular.route {
         // 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;
+        
+        /**
+         * Causes $route service to update the current URL, replacing current route parameters with those specified in newParams.
+         * Provided property names that match the route's path segment definitions will be interpolated into the
+         * location's path, while remaining properties will be treated as query params.
+         *
+         * @param newParams Object.<string, string> mapping of URL parameter names to values
+         */
+        updateParams(newParams:{[key:string]:string}): void;
+
     }
 
 
@@ -118,6 +128,12 @@ declare module angular.route {
     }
 
     interface IRouteProvider extends IServiceProvider {
+		/**
+         * Match routes without being case sensitive
+         *
+         * This option defaults to false. If the option is set to true, then the particular route can be matched without being case sensitive
+         */
+        caseInsensitiveMatch?: boolean;
         /**
          * Sets route definition that will be used on route change when no other route definition is matched.
          *

angularjs/angular-tests.ts

@@ -296,6 +296,17 @@ module TestQ {
         result = $q.reject('');
     }
 
+    // $q.resolve
+    {
+        let result: angular.IPromise<void>;
+        result = $q.resolve();
+    }
+    {
+        let result: angular.IPromise<TResult>;
+        result = $q.resolve<TResult>(tResult);
+        result = $q.resolve<TResult>(promiseTResult);
+    }
+
     // $q.when
     {
         let result: angular.IPromise<void>;
@@ -387,35 +398,47 @@ module TestPromise {
 
     var tresult: TResult;
     var tresultPromise: ng.IPromise<TResult>;
-    
+    var tresultHttpPromise: ng.IHttpPromise<TResult>;
+
     var tother: TOther;
     var totherPromise: ng.IPromise<TOther>;
-    
+    var totherHttpPromise: ng.IHttpPromise<TOther>;
+
     var promise: angular.IPromise<TResult>;
 
     // promise.then
     result = <angular.IPromise<any>>promise.then((result) => any);
     result = <angular.IPromise<any>>promise.then((result) => any, (any) => any);
     result = <angular.IPromise<any>>promise.then((result) => any, (any) => any, (any) => any);
-    
+
     result = <angular.IPromise<TResult>>promise.then((result) => result);
     result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any);
     result = <angular.IPromise<TResult>>promise.then((result) => result, (any) => any, (any) => any);
     result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise);
     result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any);
     result = <angular.IPromise<TResult>>promise.then((result) => tresultPromise, (any) => any, (any) => any);
-    
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.then((result) => tresultHttpPromise, (any) => any, (any) => any);
+
     result = <angular.IPromise<TOther>>promise.then((result) => tother);
     result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any);
     result = <angular.IPromise<TOther>>promise.then((result) => tother, (any) => any, (any) => any);
     result = <angular.IPromise<TOther>>promise.then((result) => totherPromise);
     result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any);
     result = <angular.IPromise<TOther>>promise.then((result) => totherPromise, (any) => any, (any) => any);
-    
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.then((result) => totherHttpPromise, (any) => any, (any) => any);
+
     // promise.catch
     result = <angular.IPromise<any>>promise.catch((err) => any);
     result = <angular.IPromise<TResult>>promise.catch((err) => tresult);
+    result = <angular.IPromise<TResult>>promise.catch((err) => tresultPromise);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TResult>>>promise.catch((err) => tresultHttpPromise);
     result = <angular.IPromise<TOther>>promise.catch((err) => tother);
+    result = <angular.IPromise<TOther>>promise.catch((err) => totherPromise);
+    result = <angular.IPromise<ng.IHttpPromiseCallbackArg<TOther>>>promise.catch((err) => totherHttpPromise);
 
     // promise.finally
     result = <angular.IPromise<TResult>>promise.finally(() => any);
@@ -484,7 +507,7 @@ function test_IAttributes(attributes: ng.IAttributes){
 }
 
 test_IAttributes({
-    $normalize: function (classVal){},
+    $normalize: function (classVal){ return "foo" },
     $addClass: function (classVal){},
     $removeClass: function(classVal){},
     $set: function(key, value){},
@@ -934,18 +957,114 @@ function NgModelControllerTyping() {
     };
 }
 
-function ngFilterTyping() {
-    var $filter:  angular.IFilterService;
+var $filter:  angular.IFilterService;
+
+function testFilter() {
+
     var items: string[];
-    
-    $filter("name")(items, "test");
-    $filter("name")(items, {name: "test"});
-    $filter("name")(items, (val, index, array) => {
-        return array;
+    $filter("filter")(items, "test");
+    $filter("filter")(items, {name: "test"});
+    $filter("filter")(items, (val, index, array) => {
+        return true;
     });
-    $filter("name")(items, (val, index, array) => {
-        return array;
+    $filter("filter")(items, (val, index, array) => {
+      return true;
     }, (actual, expected) => {
         return actual == expected;
     });
-}
+}
+
+function testCurrency() {
+    $filter("currency")(126);
+    $filter("currency")(126, "$", 2);
+}
+
+function testNumber() {
+    $filter("number")(167);
+    $filter("number")(167, 2);
+}
+
+function testDate() {
+    $filter("date")(new Date());
+    $filter("date")(new Date(), 'yyyyMMdd');
+    $filter("date")(new Date(), 'yyyyMMdd', '+0430');
+}
+
+function testJson() {
+    var json: string = $filter("json")({test:true}, 2);
+}
+
+function testLowercase() {
+    var lower: string = $filter("lowercase")('test');
+}
+
+function testUppercase() {
+    var lower: string = $filter("uppercase")('test');
+}
+
+function testLimitTo() {
+    var limitTo = $filter("limitTo");
+    var filtered: number[] = $filter("limitTo")([1,2,3], 5);
+    filtered = $filter("limitTo")([1,2,3], 5, 2);
+
+    var filteredString: string = $filter("limitTo")("124", 4);
+    filteredString = $filter("limitTo")(124, 4);
+}
+
+function testOrderBy() {
+    var filtered: number[] = $filter("orderBy")([1,2,3], "test");
+    filtered = $filter("orderBy")([1,2,3], "test", true);
+    filtered = $filter("orderBy")([1,2,3], ['prop1', 'prop2']);
+    filtered = $filter("orderBy")([1,2,3], (val: number) => 1);
+    var filtered2: string[] = $filter("orderBy")(["1","2","3"], (val: string) => 1);
+    filtered2 = $filter("orderBy")(["1","2","3"], [
+        (val: string) => 1,
+        (val: string) => 2
+    ]);
+}
+
+function testDynamicFilter() {
+    // Test with separate variables
+    var dateFilter = $filter("date");
+    var myDate = new Date();
+    dateFilter(myDate , "EEE, MMM d");
+
+    // Test with dynamic name
+    var filterName = 'date';
+    var dynDateFilter = $filter<ng.IFilterDate>(filterName);
+    dynDateFilter(new Date());
+}
+
+interface MyCustomFilter {
+    (value: string): string;
+}
+
+function testCustomFilter() {
+    var filterCustom = $filter<MyCustomFilter>('custom');
+    var filtered: string = filterCustom("test");
+}
+
+function parseTyping() {
+    var $parse: angular.IParseService;
+    var compiledExp = $parse('a.b.c');
+    if (compiledExp.constant) {
+        return compiledExp({});
+    } else if (compiledExp.literal) {
+        return compiledExp({}, {a: {b: {c: 42}}});
+    }
+}
+
+function doBootstrap(element: Element | JQuery, mode: string): ng.auto.IInjectorService {
+    if (mode === 'debug') {
+        return angular.bootstrap(element, ['main', function($provide: ng.auto.IProvideService) {
+            $provide.decorator('$rootScope', function($delegate: ng.IRootScopeService) {
+                $delegate['debug'] = true;
+            });
+        }, 'debug-helpers'], {
+            debugInfoEnabled: true
+        });
+    }
+    return angular.bootstrap(element, ['main'], {
+        debugInfoEnabled: false
+    });
+}

angularjs/angular.d.ts

@@ -41,6 +41,7 @@ declare module angular {
 
     interface IAngularBootstrapConfig {
         strictDi?: boolean;
+        debugInfoEnabled?: boolean;
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -56,132 +57,11 @@ declare module angular {
          * @param element DOM element which is the root of angular application.
          * @param modules An array of modules to load into the application.
          *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
+         *     function that will be invoked by the injector as a config block.
          * @param config an object for defining configuration options for the application. The following keys are supported:
          *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
          */
-        bootstrap(element: string, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: string, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: string, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: JQuery, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: JQuery, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: JQuery, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Element, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Element, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Element, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Document, modules?: string, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Document, modules?: Function, config?: IAngularBootstrapConfig): auto.IInjectorService;
-        /**
-         * Use this function to manually start up angular application.
-         *
-         * @param element DOM element which is the root of angular application.
-         * @param modules An array of modules to load into the application.
-         *     Each item in the array should be the name of a predefined module or a (DI annotated)
-         *     function that will be invoked by the injector as a run block.
-         * @param config an object for defining configuration options for the application. The following keys are supported:
-         *     - `strictDi`: disable automatic function annotation for the application. This is meant to assist in finding bugs which break minified code.
-         */
-        bootstrap(element: Document, modules?: string[], config?: IAngularBootstrapConfig): auto.IInjectorService;
+        bootstrap(element: string|Element|JQuery|Document, modules?: (string|Function|any[])[], config?: IAngularBootstrapConfig): auto.IInjectorService;
 
         /**
          * Creates a deep copy of source, which should be an object or an array.
@@ -285,6 +165,12 @@ declare module angular {
             dot: number;
             codeName: string;
         };
+
+        /**
+         * If window.name contains prefix NG_DEFER_BOOTSTRAP! when angular.bootstrap is called, the bootstrap process will be paused until angular.resumeBootstrap() is called.
+         * @param extraModules An optional array of modules that should be added to the original list of modules that the app was about to be bootstrapped with.
+         */
+        resumeBootstrap?(extraModules?: string[]): ng.auto.IInjectorService;
     }
 
     ///////////////////////////////////////////////////////////////////////////
@@ -295,6 +181,13 @@ declare module angular {
         animation(name: string, animationFactory: Function): IModule;
         animation(name: string, inlineAnnotatedFunction: any[]): IModule;
         animation(object: Object): IModule;
+        /**
+         * Use this method to register a component.
+         *
+         * @param name The name of the component.
+         * @param options A definition object passed into the component.
+         */
+        component(name: string, options: IComponentOptions): IModule;
         /**
          * Use this method to register work which needs to be performed on module loading.
          *
@@ -426,7 +319,7 @@ declare module angular {
          *
          * For further information check out the guide on @see https://docs.angularjs.org/guide/directive#matching-directives
          */
-        $normalize(name: string): void;
+        $normalize(name: string): string;
 
         /**
          * Adds the CSS class value specified by the classVal parameter to the
@@ -674,7 +567,7 @@ declare module angular {
          */
         $odd: boolean;
 
-	}
+    }
 
     interface IAngularEvent {
         /**
@@ -735,12 +628,12 @@ declare module angular {
     // see http://docs.angularjs.org/api/ng.$interval
     ///////////////////////////////////////////////////////////////////////////
     interface IIntervalService {
-        (func: Function, delay: number, count?: number, invokeApply?: boolean): IPromise<any>;
+        (func: Function, delay: number, count?: number, invokeApply?: boolean, ...args: any[]): IPromise<any>;
         cancel(promise: IPromise<any>): boolean;
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    // AngularProvider
+    // AnimateProvider
     // see http://docs.angularjs.org/api/ng/provider/$animateProvider
     ///////////////////////////////////////////////////////////////////////////
     interface IAnimateProvider {
@@ -776,31 +669,127 @@ declare module angular {
      * see https://docs.angularjs.org/api/ng/service/$filter
      */
     interface IFilterService {
+        (name: 'filter'): IFilterFilter;
+        (name: 'currency'): IFilterCurrency;
+        (name: 'number'): IFilterNumber;
+        (name: 'date'): IFilterDate;
+        (name: 'json'): IFilterJson;
+        (name: 'lowercase'): IFilterLowercase;
+        (name: 'uppercase'): IFilterUppercase;
+        (name: 'limitTo'): IFilterLimitTo;
+        (name: 'orderBy'): IFilterOrderBy;
         /**
          * Usage:
          * $filter(name);
          *
          * @param name Name of the filter function to retrieve
          */
-        (name: string): IFilterFunc;
+        <T>(name: string): T;
     }
-    
-    interface IFilterFunc {
-        <T>(array: T[], expression: string | IFilterPatternObject | IFilterPredicateFunc<T>, comparator?: IFilterComparatorFunc<T>|boolean): T[];
+
+    interface IFilterFilter {
+        <T>(array: T[], expression: string | IFilterFilterPatternObject | IFilterFilterPredicateFunc<T>, comparator?: IFilterFilterComparatorFunc<T>|boolean): T[];
     }
-    
-    interface IFilterPatternObject {
-        [name: string]: string;
+
+    interface IFilterFilterPatternObject {
+        [name: string]: any;
     }
-    
-    interface IFilterPredicateFunc<T> {
-        (value: T, index: number, array: T[]): T[];
+
+    interface IFilterFilterPredicateFunc<T> {
+        (value: T, index: number, array: T[]): boolean;
     }
-    
-    interface IFilterComparatorFunc<T> {
+
+    interface IFilterFilterComparatorFunc<T> {
         (actual: T, expected: T): boolean;
     }
 
+    interface IFilterCurrency {
+        /**
+         * Formats a number as a currency (ie $1,234.56). When no currency symbol is provided, default symbol for current locale is used.
+         * @param amount Input to filter.
+         * @param symbol Currency symbol or identifier to be displayed.
+         * @param fractionSize Number of decimal places to round the amount to, defaults to default max fraction size for current locale
+         * @return Formatted number
+         */
+        (amount: number, symbol?: string, fractionSize?: number): string;
+    }
+
+    interface IFilterNumber {
+        /**
+         * Formats a number as text.
+         * @param number Number to format.
+         * @param fractionSize Number of decimal places to round the number to. If this is not provided then the fraction size is computed from the current locale's number formatting pattern. In the case of the default locale, it will be 3.
+         * @return Number rounded to decimalPlaces and places a “,” after each third digit.
+         */
+        (value: number|string, fractionSize?: number|string): string;
+    }
+
+    interface IFilterDate {
+        /**
+         * Formats date to a string based on the requested format.
+         *
+         * @param date Date to format either as Date object, milliseconds (string or number) or various ISO 8601 datetime string formats (e.g. yyyy-MM-ddTHH:mm:ss.sssZ and its shorter versions like yyyy-MM-ddTHH:mmZ, yyyy-MM-dd or yyyyMMddTHHmmssZ). If no timezone is specified in the string input, the time is considered to be in the local timezone.
+         * @param format Formatting rules (see Description). If not specified, mediumDate is used.
+         * @param timezone Timezone to be used for formatting. It understands UTC/GMT and the continental US time zone abbreviations, but for general use, use a time zone offset, for example, '+0430' (4 hours, 30 minutes east of the Greenwich meridian) If not specified, the timezone of the browser will be used.
+         * @return Formatted string or the input if input is not recognized as date/millis.
+         */
+        (date: Date | number | string, format?: string, timezone?: string): string;
+    }
+
+    interface IFilterJson {
+        /**
+         * Allows you to convert a JavaScript object into JSON string.
+         * @param object Any JavaScript object (including arrays and primitive types) to filter.
+         * @param spacing The number of spaces to use per indentation, defaults to 2.
+         * @return JSON string.
+         */
+        (object: any, spacing?: number): string;
+    }
+
+    interface IFilterLowercase {
+        /**
+         * Converts string to lowercase.
+         */
+        (value: string): string;
+    }
+
+    interface IFilterUppercase {
+        /**
+         * Converts string to uppercase.
+         */
+        (value: string): string;
+    }
+
+    interface IFilterLimitTo {
+        /**
+         * Creates a new array containing only a specified number of elements. The elements are taken from either the beginning or the end of the source array, string or number, as specified by the value and sign (positive or negative) of limit.
+         * @param input Source array to be limited.
+         * @param limit The length of the returned array. If the limit number is positive, limit number of items from the beginning of the source array/string are copied. If the number is negative, limit number of items from the end of the source array are copied. The limit will be trimmed if it exceeds array.length. If limit is undefined, the input will be returned unchanged.
+         * @param begin Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0.
+         * @return A new sub-array of length limit or less if input array had less than limit elements.
+         */
+        <T>(input: T[], limit: string|number, begin?: string|number): T[];
+        /**
+         * Creates a new string containing only a specified number of elements. The elements are taken from either the beginning or the end of the source string or number, as specified by the value and sign (positive or negative) of limit. If a number is used as input, it is converted to a string.
+         * @param input Source string or number to be limited.
+         * @param limit The length of the returned string. If the limit number is positive, limit number of items from the beginning of the source string are copied. If the number is negative, limit number of items from the end of the source string are copied. The limit will be trimmed if it exceeds input.length. If limit is undefined, the input will be returned unchanged.
+         * @param begin Index at which to begin limitation. As a negative index, begin indicates an offset from the end of input. Defaults to 0.
+         * @return A new substring of length limit or less if input had less than limit elements.
+         */
+        (input: string|number, limit: string|number, begin?: string|number): string;
+    }
+
+    interface IFilterOrderBy {
+        /**
+         * Orders a specified array by the expression predicate. It is ordered alphabetically for strings and numerically for numbers. Note: if you notice numbers are not being sorted as expected, make sure they are actually being saved as numbers and not strings.
+         * @param array The array to sort.
+         * @param expression A predicate to be used by the comparator to determine the order of elements.
+         * @param reverse Reverse the order of the array.
+         * @return Reverse the order of the array.
+         */
+        <T>(array: T[], expression: string|((value: T) => any)|(((value: T) => any)|string)[], reverse?: boolean): T[];
+    }
+
     /**
      * $filterProvider - $filter - provider in module ng
      *
@@ -910,6 +899,9 @@ declare module angular {
     interface ICompiledExpression {
         (context: any, locals?: any): any;
 
+        literal: boolean;
+        constant: boolean;
+
         // 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.
@@ -1052,12 +1044,20 @@ declare module angular {
          *
          * @param value Value or a promise
          */
-        when<T>(value: IPromise<T>|T): IPromise<T>;
+        resolve<T>(value: IPromise<T>|T): IPromise<T>;
+        /**
+         * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
+         */
+        resolve(): IPromise<void>;
         /**
          * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
          *
          * @param value Value or a promise
          */
+        when<T>(value: IPromise<T>|T): IPromise<T>;
+        /**
+         * Wraps an object that might be a value or a (3rd party) then-able promise into a $q promise. This is useful when you are dealing with an object that might or might not be a promise, or if the promise comes from a source that can't be trusted.
+         */
         when(): IPromise<void>;
     }
 
@@ -1067,12 +1067,12 @@ declare module angular {
          * The successCallBack may return IPromise<void> for when a $q.reject() needs to be returned
          * This method returns a new promise which is resolved or rejected via the return value of the successCallback, errorCallback. It also notifies via the return value of the notifyCallback method. The promise can not be resolved or rejected from the notifyCallback method.
          */
-        then<TResult>(successCallback: (promiseValue: T) => IHttpPromise<TResult>|IPromise<TResult>|TResult|IPromise<void>, errorCallback?: (reason: any) => any, notifyCallback?: (state: any) => any): IPromise<TResult>;
+        then<TResult>(successCallback: (promiseValue: T) => IPromise<TResult>|TResult, errorCallback?: (reason: any) => any, notifyCallback?: (state: any) => any): IPromise<TResult>;
 
         /**
          * Shorthand for promise.then(null, errorCallback)
          */
-        catch<TResult>(onRejected: (reason: any) => IHttpPromise<TResult>|IPromise<TResult>|TResult): IPromise<TResult>;
+        catch<TResult>(onRejected: (reason: any) => IPromise<TResult>|TResult): IPromise<TResult>;
 
         /**
          * Allows you to observe either the fulfillment or rejection of a promise, but to do so without modifying the final value. This is useful to release resources or do some clean-up that needs to be done whether the promise was rejected or resolved. See the full specification for more information.
@@ -1400,11 +1400,10 @@ declare module angular {
     interface IHttpPromise<T> extends IPromise<IHttpPromiseCallbackArg<T>> {
         success(callback: IHttpPromiseCallback<T>): IHttpPromise<T>;
         error(callback: IHttpPromiseCallback<any>): IHttpPromise<T>;
-        then<TResult>(successCallback: (response: IHttpPromiseCallbackArg<T>) => IPromise<TResult>|TResult, errorCallback?: (response: IHttpPromiseCallbackArg<any>) => any): IPromise<TResult>;
     }
 
     // See the jsdoc for transformData() at https://github.com/angular/angular.js/blob/master/src/ng/http.js#L228
-    interface IHttpResquestTransformer {
+    interface IHttpRequestTransformer {
         (data: any, headersGetter: IHttpHeadersGetter): any;
     }
 
@@ -1441,7 +1440,7 @@ declare module angular {
          * headers and returns its transformed (typically serialized) version.
          * @see {@link https://docs.angularjs.org/api/ng/service/$http#transforming-requests-and-responses}
          */
-        transformRequest?: IHttpResquestTransformer |IHttpResquestTransformer[];
+        transformRequest?: IHttpRequestTransformer |IHttpRequestTransformer[];
 
         /**
          * Transform function or an array of such functions. The transform function takes the http response body and
@@ -1628,6 +1627,110 @@ declare module angular {
         totalPendingRequests: number;
     }
 
+    ///////////////////////////////////////////////////////////////////////////
+    // Component
+    // see http://angularjs.blogspot.com.br/2015/11/angularjs-15-beta2-and-14-releases.html
+    // and http://toddmotto.com/exploring-the-angular-1-5-component-method/
+    ///////////////////////////////////////////////////////////////////////////
+    /**
+     * Runtime representation a type that a Component or other object is instances of.
+     *
+     * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is be represented by
+     * the `MyCustomComponent` constructor function.
+     */
+    interface Type extends Function {
+    }
+
+    /**
+     * `RouteDefinition` defines a route within a {@link RouteConfig} decorator.
+     *
+     * Supported keys:
+     * - `path` or `aux` (requires exactly one of these)
+     * - `component`, `loader`,  `redirectTo` (requires exactly one of these)
+     * - `name` or `as` (optional) (requires exactly one of these)
+     * - `data` (optional)
+     *
+     * See also {@link Route}, {@link AsyncRoute}, {@link AuxRoute}, and {@link Redirect}.
+     */
+    interface RouteDefinition {
+        path?: string;
+        aux?: string;
+        component?: Type | ComponentDefinition | string;
+        loader?: Function;
+        redirectTo?: any[];
+        as?: string;
+        name?: string;
+        data?: any;
+        useAsDefault?: boolean;
+    }
+
+    /**
+     * Represents either a component type (`type` is `component`) or a loader function
+     * (`type` is `loader`).
+     *
+     * See also {@link RouteDefinition}.
+     */
+    interface ComponentDefinition {
+        type: string;
+        loader?: Function;
+        component?: Type;
+    }
+
+    /**
+     * Component definition object (a simplified directive definition object)
+     */
+    interface IComponentOptions {
+        /**
+         * Controller constructor function that should be associated with newly created scope or the name of a registered
+         * controller if passed as a string. Empty function by default.
+         */
+        controller?: string | Function;
+        /**
+         * An identifier name for a reference to the controller. If present, the controller will be published to scope under
+         * the controllerAs name. If not present, this will default to be the same as the component name.
+         */
+        controllerAs?: string;
+        /**
+         * html template as a string or a function that returns an html template as a string which should be used as the
+         * contents of this component. Empty string by default.
+         * If template is a function, then it is injected with the following locals:
+         * $element - Current element
+         * $attrs - Current attributes object for the element
+         */
+        template?: string | Function;
+        /**
+         * path or function that returns a path to an html template that should be used as the contents of this component.
+         * If templateUrl is a function, then it is injected with the following locals:
+         * $element - Current element
+         * $attrs - Current attributes object for the element
+         */
+        templateUrl?: string | Function;
+        /**
+         * Define DOM attribute binding to component properties. Component properties are always bound to the component
+         * controller and not to the scope.
+         */
+        bindings?: any;
+        /**
+         * Whether transclusion is enabled. Enabled by default.
+         */
+        transclude?: boolean;
+        /**
+         * Whether the new scope is isolated. Isolated by default.
+         */
+        isolate?: boolean;
+        /**
+         * String of subset of EACM which restricts the component to specific directive declaration style. If omitted,
+         * this defaults to 'E'.
+         */
+        restrict?: string;
+        $canActivate?: () => boolean;
+        $routeConfig?: RouteDefinition[];
+    }
+
+    interface IComponentTemplateFn {
+        ( $element?: IAugmentedJQuery, $attrs?: IAttributes ): string;
+    }
+
     ///////////////////////////////////////////////////////////////////////////
     // Directive
     // see http://docs.angularjs.org/api/ng.$compileProvider#directive
@@ -1674,6 +1777,7 @@ declare module angular {
         restrict?: string;
         scope?: any;
         template?: any;
+        templateNamespace?: string;
         templateUrl?: any;
         terminal?: boolean;
         transclude?: any;

angularjs/legacy/angular-cookies-1.0.d.ts

@@ -1,4 +1,4 @@
-/// Type definitions for Angular JS 1.0 (ngCookies module)
+// 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

angularjs/legacy/angular-scenario-1.0.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for Angular Scenario Testing 1.0 (ngScenario module)
-// Project: [http://angularjs.org]
-// Definitions by: [RomanoLindano]
+// Project: http://angularjs.org
+// Definitions by: RomanoLindano <https://github.com/RomanoLindano>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 declare module angularScenario {

angulartics/angulartics.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Angulartics v0.19.2
+// Type definitions for Angulartics v0.20.2
 // Project: http://luisfarzati.github.io/angulartics/
 // Definitions by: Steven Fan <https://github.com/stevenfan>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -21,6 +21,7 @@ declare module angulartics {
 
     interface IAnalyticsServiceProvider extends angular.IServiceProvider {
         virtualPageviews(value: boolean): void;
+        excludeRoutes(value: string[]): void;
         firstPageview(value: boolean): void;
         withBase(value: boolean): void;
         withAutoBase(value: boolean): void;

any-db/any-db.d.ts

@@ -50,7 +50,7 @@ declare module "any-db" {
 		/**
 		 * Result rows
 		 */
-		rows: Object[];
+		rows: any[];
 		/**
 		 * Result field descriptions
 		 */

anydb-sql-migrations/anydb-sql-migrations-tests.ts

@@ -0,0 +1,17 @@
+/// <reference path="../anydb-sql/anydb-sql.d.ts" />
+/// <reference path="anydb-sql-migrations" />
+import anydbsql = require('anydb-sql');
+import { Table, Column } from 'anydb-sql'
+import migrator = require('anydb-sql-migrations');
+
+function do_not_run() {
+
+    var db = anydbsql({
+        url: 'postgres://user:pass@host:port/database',
+        connections: { min: 2, max: 20 }
+    });
+
+    migrator
+    .create(db, '/path/to/migrations/dir')
+    .run();
+}