Merge remote-tracking branch 'upstream/master'

CONTRIBUTORS.md

@@ -1119,6 +1119,7 @@ This document generated by [dt-contributors-generator](https://github.com/vvakam
 * [:link:](simple-cw-node/simple-cw-node.d.ts) [simple-cw-node](https://github.com/astronaughts/simple-cw-node) by [vvakame](https://github.com/vvakame)
 * [:link:](simplebar/simplebar.d.ts) [simplebar.js](https://github.com/Grsmto/simplebar) by [Gregor Woiwode](https://github.com/gregonnet)
 * [:link:](jquery.simplemodal/jquery.simplemodal.d.ts) [SimpleModal](http://www.ericmmartin.com/projects/simplemodal) by [Friedrich von Never](https://github.com/ForNeVeR)
+* [:link:](simpleStorage/simplestorage.js.d.ts) [simpleStorage](https://github.com/andris9/simpleStorage) by [Áxel Costas Pena](https://github.com/axelcostaspena)
 * [:link:](sinon/sinon.d.ts) [Sinon](http://sinonjs.org) by [William Sears](https://github.com/mrbigdog2u)
 * [:link:](sinon-chai/sinon-chai.d.ts) [sinon-chai](https://github.com/domenic/sinon-chai) by [Kazi Manzur Rashid](https://github.com/kazimanzurrashid), [Jed Mao](https://github.com/jedmao)
 * [:link:](sinon-chrome/sinon-chrome.d.ts) [Sinon-Chrome](https://github.com/vitalets/sinon-chrome) by [Tim Perry](https://github.com/pimterry)

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

@@ -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.
 

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 {

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 = {};
+}

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

@@ -80,3 +80,12 @@ function testIntegrations(): void {
     }
   });
 }
+
+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

@@ -65,6 +65,16 @@ declare module AnalyticsNode {
       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;
   }
 }
 

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-formly/angular-formly.d.ts

@@ -297,6 +297,7 @@ declare module AngularFormly {
 			bound?: any;
 			expression?: any;
 			value?: any;
+			[key: string]: any;
 		};
 
 

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-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-loading-bar/angular-loading-bar-tests.ts

@@ -0,0 +1,15 @@
+/// <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);

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

@@ -0,0 +1,18 @@
+// 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;
+	}
+
+}

angular-material/angular-material.d.ts

@@ -221,4 +221,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-ui-router/angular-ui-router.d.ts

@@ -71,10 +71,16 @@ declare module angular.ui {
          * 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,10 +235,10 @@ 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;
@@ -244,10 +250,10 @@ declare module angular.ui {
         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;
     }

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]',
-    inputs: [
-      'text: tooltip'
-    ],
-    outputs: [
-      '(mouseenter):onMouseEnter()',
-      '(mouseleave):onMouseLeave()'
-    ]
-  })
-];
-
-@Component({selector: 'cmp2'})
-@View({templateUrl: '/index.html'})
-class Cmp2 {
-  
-}
-
-bootstrap(Cmp);
+// No tests, because angular 2 typings are not in DefinitelyTyped.

angular2/angular2-tests.ts.tscparams

@@ -1 +0,0 @@
---experimentalDecorators --noImplicitAny --target ES5

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/http-2.0.0-alpha.38.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.38.d.ts"/>
 
 
 

angular2/http-2.0.0-alpha.39.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.39.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-2.0.0-alpha.38.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.38.d.ts"/>
 
 
 

angular2/router-2.0.0-alpha.39.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.39.d.ts"/>
 
 
 

angular2/test_lib-2.0.0-alpha.38.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.38.d.ts"/>
 ///<reference path="../jasmine/jasmine.d.ts"/>
 
 

angular2/test_lib-2.0.0-alpha.39.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.39.d.ts"/>
 ///<reference path="../jasmine/jasmine.d.ts"/>
 
 

angular2/test_lib.d.ts

@@ -1,408 +0,0 @@
-// 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.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-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' };
+});
 
 
 ///////////////////////////////////////

angularjs/angular-resource.d.ts

@@ -46,11 +46,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.

angularjs/angular.d.ts

@@ -620,7 +620,7 @@ declare module angular {
     }
 
     ///////////////////////////////////////////////////////////////////////////
-    // AngularProvider
+    // AnimateProvider
     // see http://docs.angularjs.org/api/ng/provider/$animateProvider
     ///////////////////////////////////////////////////////////////////////////
     interface IAnimateProvider {
@@ -1390,7 +1390,7 @@ declare module angular {
     }
 
     // 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;
     }
 
@@ -1427,7 +1427,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

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 {

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();
+}

anydb-sql-migrations/anydb-sql-migrations.d.ts

@@ -0,0 +1,34 @@
+// Type definitions for anydb-sql-migrations
+// Project: https://github.com/spion/anydb-sql-migrations
+// Definitions by: Gorgi Kosev <https://github.com/spion>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../bluebird/bluebird.d.ts" />
+/// <reference path="../anydb-sql/anydb-sql.d.ts" />
+
+declare module "anydb-sql-migrations" {
+    import Promise = require('bluebird');
+    import { Column, Table, Transaction, AnydbSql } from 'anydb-sql';
+    export interface Migration {
+        version: string;
+    }
+    export interface MigrationsTable extends Table<Migration> {
+        version: Column<string>;
+    }
+    export interface MigFn {
+        (tx: Transaction): Promise<any>;
+    }
+    export interface MigrationTask {
+        up: MigFn;
+        down: MigFn;
+        name: string;
+    }
+    export function create(db: AnydbSql, tasks: any): {
+        run: () => Promise<any>;
+        migrateTo: (target?: string) => Promise<any>;
+        check: (f: (m: {
+            type: string;
+            items: MigrationTask[];
+        }) => any) => Promise<any>;
+    };
+}

anydb-sql/anydb-sql-tests.ts

@@ -0,0 +1,70 @@
+/// <reference path="anydb-sql.d.ts" />
+import anydbsql = require('anydb-sql');
+import { Table, Column } from 'anydb-sql'
+
+function do_not_run() {
+
+    var db = anydbsql({
+        url: 'postgres://user:pass@host:port/database',
+        connections: { min: 2, max: 20 }
+    });
+
+    // Table Post
+
+    interface Post {
+        content: string;
+        userId: string;
+        date: string;
+    }
+
+    interface PostTable extends Table<Post> {
+        content: Column<string>;
+        userId: Column<string>;
+        date: Column<string>;
+    }
+
+    var post = <PostTable>db.define<Post>({
+        name: 'posts',
+        columns: {
+            content: {},
+            userId: {},
+            date: {}
+        }
+    });
+
+    // Table User
+
+    interface User {
+        id: string;
+        email: string;
+        password: string;
+        name: string;
+    }
+
+    interface UserTable extends Table<User> {
+        id: Column<string>;
+        email: Column<string>;
+        password: Column<string>;
+        name: Column<string>;
+    }
+
+    var user = <UserTable>db.define<User>({
+        name: 'users',
+        columns: {
+            id: { primaryKey: true },
+            email: {},
+            password: {},
+            name: {},
+            date: {}
+        },
+        has: {
+            posts: { from: 'posts', many: true },
+            group: { from: 'groups'}
+        }
+    });
+
+    user.select(user.name, post.content)
+      .from(user.join(post).on(user.id.equals(post.userId)))
+      .where(post.date.gt('123'))
+      .all()
+}

anydb-sql/anydb-sql.d.ts

@@ -0,0 +1,194 @@
+// Type definitions for anydb-sql
+// Project: https://github.com/doxout/anydb-sql
+// Definitions by: Gorgi Kosev <https://github.com/spion>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference path="../bluebird/bluebird.d.ts" />
+
+declare module "anydb-sql" {
+    import Promise = require('bluebird');
+
+    interface AnyDBPool extends anydbSQL.DatabaseConnection {
+        query:(text:string, values:any[], callback:(err:Error, result:any)=>void)=>void
+        begin:()=>anydbSQL.Transaction
+        close:(err:Error)=>void
+    }
+
+    interface Dictionary<T> { [key:string]:T; }
+
+    module anydbSQL {
+        export interface OrderByValueNode {}
+        export interface ColumnDefinition {
+            primaryKey?:boolean;
+            dataType?:string;
+            references?: {table:string; column: string}
+            notNull?:boolean
+        }
+
+        export interface TableDefinition {
+            name:string
+            columns:Dictionary<ColumnDefinition>
+            has?:Dictionary<{from:string; many?:boolean}>
+        }
+
+
+        export interface QueryLike {
+            query:string;
+            values: any[]
+            text:string
+        }
+        export interface DatabaseConnection {
+            queryAsync<T>(query:string, ...params:any[]):Promise<{rowCount:number;rows:T[]}>
+            queryAsync<T>(query:QueryLike):Promise<{rowCount:number;rows:T[]}>
+        }
+
+        export interface Transaction extends DatabaseConnection {
+            rollback():void
+            commitAsync():Promise<void>
+        }
+
+        export interface SubQuery<T> {
+            select(node:Column<T>):SubQuery<T>
+            where(...nodes:any[]):SubQuery<T>
+            from(table:TableNode):SubQuery<T>
+            group(...nodes:any[]):SubQuery<T>
+            order(criteria:OrderByValueNode):SubQuery<T>
+            notExists(subQuery:SubQuery<any>):SubQuery<T>
+        }
+
+        interface Executable<T> {
+            get():Promise<T>
+            getWithin(tx:DatabaseConnection):Promise<T>
+            exec():Promise<void>
+            all():Promise<T[]>
+            execWithin(tx:DatabaseConnection):Promise<void> 
+            allWithin(tx:DatabaseConnection):Promise<T[]>
+            toQuery():QueryLike;
+        }
+
+        interface Queryable<T> {
+            where(...nodes:any[]):Query<T>
+            delete():ModifyingQuery
+            select<U>(...nodes:any[]):Query<U>
+            selectDeep<U>(table: Table<T>): Query<T>
+            selectDeep<U>(...nodesOrTables:any[]):Query<U>
+        }
+
+        export interface Query<T> extends Executable<T>, Queryable<T> {
+            from(table:TableNode):Query<T>
+            update(o:Dictionary<any>):ModifyingQuery
+            update(o:{}):ModifyingQuery
+            group(...nodes:any[]):Query<T>
+            order(...criteria:OrderByValueNode[]):Query<T>
+            limit(l:number):Query<T>
+            offset(o:number):Query<T>
+        }
+
+        export interface ModifyingQuery extends Executable<void> {
+            returning<U>(...nodes:any[]):Query<U>
+            where(...nodes:any[]):ModifyingQuery
+        }
+
+        export interface TableNode {
+            join(table:TableNode):JoinTableNode
+            leftJoin(table:TableNode):JoinTableNode
+        }
+
+        export interface JoinTableNode extends TableNode {
+            on(filter:BinaryNode):TableNode
+            on(filter:string):TableNode
+        }
+
+        interface CreateQuery extends Executable<void> {
+            ifNotExists():Executable<void>
+        }
+        interface DropQuery extends Executable<void> {
+            ifExists():Executable<void>
+        }
+        export interface Table<T> extends TableNode, Queryable<T> {
+            create():CreateQuery
+            drop():DropQuery
+            as(name:string):Table<T>
+            update(o:any):ModifyingQuery
+            insert(row:T):ModifyingQuery
+            insert(rows:T[]):ModifyingQuery
+            select():Query<T>
+            select<U>(...nodes:any[]):Query<U>
+            from<U>(table:TableNode):Query<U>
+            star():Column<any>
+            subQuery<U>():SubQuery<U>
+            eventEmitter:{emit:(type:string, ...args:any[])=>void
+                          on:(eventName:string, handler:Function)=>void}
+            columns:Column<any>[]
+            sql: SQL;
+            alter():AlterQuery<T>
+        }
+        export interface AlterQuery<T> extends Executable<void> {
+            addColumn(column:Column<any>): AlterQuery<T>;
+            addColumn(name: string, options:string): AlterQuery<T>;
+            dropColumn(column: Column<any>): AlterQuery<T>;
+            renameColumn(column: Column<any>, newColumn: Column<any>):AlterQuery<T>;
+            renameColumn(column: Column<any>, newName: string):AlterQuery<T>;
+            renameColumn(name: string, newName: string):AlterQuery<T>;
+            rename(newName: string): AlterQuery<T>
+        }
+
+        export interface SQL {
+            functions: {
+                LOWER(c:Column<string>):Column<string>
+            }
+        }
+
+        export interface BinaryNode {
+            and(node:BinaryNode):BinaryNode
+            or(node:BinaryNode):BinaryNode
+        }
+
+        export interface Column<T> {
+            in(arr:T[]):BinaryNode
+            in(subQuery:SubQuery<T>):BinaryNode
+            notIn(arr:T[]):BinaryNode
+            equals(node:any):BinaryNode
+            notEquals(node:any):BinaryNode
+            gte(node:any):BinaryNode
+            lte(node:any):BinaryNode
+            gt(node:any):BinaryNode
+            lt(node:any):BinaryNode
+            like(str:string):BinaryNode
+            multiply:{
+                (node:Column<T>):Column<T>
+                (n:number):Column<number>
+            }
+            isNull():BinaryNode
+            isNotNull():BinaryNode
+            sum():Column<number>
+            count():Column<number>
+            count(name:string):Column<number>
+            distinct():Column<T>
+            as(name:string):Column<T>
+            ascending:OrderByValueNode
+            descending:OrderByValueNode
+            asc:OrderByValueNode
+            desc:OrderByValueNode
+        }
+
+        export interface AnydbSql extends DatabaseConnection {
+            define<T>(map:TableDefinition):Table<T>;
+            transaction<T>(fn:(tx:Transaction)=>Promise<T>):Promise<T>
+            allOf(...tables:Table<any>[]):any
+            models:Dictionary<Table<any>>
+            functions:{LOWER:(name:Column<string>)=>Column<string>
+                       RTRIM:(name:Column<string>)=>Column<string>}
+            makeFunction(name:string):Function
+            begin():Transaction
+            open():void;
+            close():void;
+            getPool():AnyDBPool;
+            dialect():string;
+        }
+    }
+
+    function anydbSQL(config:Object):anydbSQL.AnydbSql;
+
+    export = anydbSQL;
+}

applicationinsights/applicationinsights-tests.ts

@@ -18,6 +18,7 @@ appInsights.client.trackEvent("custom event", {customProperty: "custom property
 appInsights.client.trackException(new Error("handled exceptions can be logged with this method"));
 appInsights.client.trackMetric("custom metric", 3);
 appInsights.client.trackTrace("trace message");
+appInsights.client.trackDependency("dependency name", "commandName", 500, true);
 
 // assign common properties to all telemetry
 appInsights.client.commonProperties = {

applicationinsights/applicationinsights.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Application Insights v0.15.1
+// Type definitions for Application Insights v0.15.7
 // Project: https://github.com/Microsoft/ApplicationInsights-node.js
 // Definitions by: Scott Southwood <https://github.com/scsouthw/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -342,6 +342,19 @@ interface Client {
     trackRequest(request: any /* http.ServerRequest */, response: any /* http.ServerResponse */, properties?: {
         [key: string]: string;
     }): void;
+    /**
+     * Log information about a dependency of your app. Typically used to track the time database calls or outgoing http requests take from your server.
+     * @param name   The name of the dependency (i.e. "myDatabse")
+     * @param commandname   The name of the command executed on the dependency
+     * @param elapsedTimeMs   The amount of time in ms that the dependency took to return the result
+     * @param success         True if the dependency succeeded, false otherwise
+     * @param dependencyTypeName  The type of the dependency (i.e. "SQL" "HTTP"). Defaults to empty.
+     * @param properties   map[string, string] - additional data used to filter events and metrics in the portal. Defaults to empty.
+     * @param dependencyKind   ContractsModule.DependencyKind of this dependency. Defaults to Other.
+     * @param async  True if the dependency was executed asynchronously, false otherwise. Defaults to false
+     * @param dependencySource  ContractsModule.DependencySourceType of this dependency. Defaults to Undefined. 
+     */
+    trackDependency(name: string, commandName: string, elapsedTimeMs: number, success: boolean, dependencyTypeName?: string, properties?: {}, dependencyKind?: any, async?: boolean, dependencySource?: number): void;
     /**
      * Immediately send all queued telemetry.
      */

assertsharp/assertsharp-tests.ts

@@ -0,0 +1,16 @@
+/// <reference path="./assertsharp.d.ts" />
+
+import Assert from "assertsharp";
+
+Assert.AreEqual(0, 0, "Pass");
+Assert.AreNotEqual(0, 1, "Pass");
+Assert.AreNotSame(new Date(), new Date(), "Pass");
+Assert.AreSequenceEqual([0], [0], (x, y) => x === y, "Pass");
+Assert.Fail("Should fail");
+Assert.IsFalse(false, "Pass");
+Assert.IsInstanceOfType(new Date(), Date, "Pass");
+Assert.IsNotInstanceOfType(true, Date, "Pass");
+Assert.IsNotNull(new Date(), "Pass");
+Assert.IsNull(null, "Pass");
+Assert.IsTrue(true, "Pass");
+Assert.Throws(() => { throw ""; }, "Pass");

assertsharp/assertsharp.d.ts

@@ -0,0 +1,21 @@
+// Type definitions for assertsharp
+// Project: https://www.npmjs.com/package/assertsharp
+// Definitions by: Bruno Leonardo Michels <https://github.com/brunolm>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "assertsharp" {
+    export default class Assert {
+        static AreEqual<T>(expected: T, actual: T, message?: string): void;
+        static AreNotEqual<T>(notExpected: T, actual: T, message?: string): void;
+        static AreNotSame<T>(notExpected: T, actual: T, message?: string): void;
+        static AreSequenceEqual<T>(expected: T[], actual: T[], equals?: (x: any, y: any) => boolean, message?: string): void;
+        static Fail(message?: string): void;
+        static IsFalse(actual: boolean, message?: string): void;
+        static IsInstanceOfType(actual: any, expectedType: Function, message?: string): void;
+        static IsNotInstanceOfType(actual: any, wrongType: Function, message?: string): void;
+        static IsNotNull(actual: any, message?: string): void;
+        static IsNull(actual: any, message?: string): void;
+        static IsTrue(actual: boolean, message?: string): void;
+        static Throws(fn: () => void, message?: string): void;
+    }
+}

async/async.d.ts

@@ -1,165 +1,165 @@
-// Type definitions for Async 1.4.2
-// Project: https://github.com/caolan/async
-// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Arseniy Maximov <https://github.com/kern0>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-interface Dictionary<T> { [key: string]: T; }
-
-interface ErrorCallback { (err?: Error): void; }
-interface AsyncResultCallback<T> { (err: Error, result: T): void; }
-interface AsyncResultArrayCallback<T> { (err: Error, results: T[]): void; }
-interface AsyncResultObjectCallback<T> { (err: Error, results: Dictionary<T>): void; }
-
-interface AsyncFunction<T> { (callback: (err: Error, result?: T) => void): void; }
-interface AsyncIterator<T> { (item: T, callback: ErrorCallback): void; }
-interface AsyncForEachOfIterator<T> { (item: T, key: number, callback: ErrorCallback): void; }
-interface AsyncResultIterator<T, R> { (item: T, callback: AsyncResultCallback<R>): void; }
-interface AsyncMemoIterator<T, R> { (memo: R, item: T, callback: AsyncResultCallback<R>): void; }
-interface AsyncBooleanIterator<T> { (item: T, callback: (truthValue: boolean) => void): void; }
-
-interface AsyncWorker<T> { (task: T, callback: ErrorCallback): void; }
-interface AsyncVoidFunction { (callback: ErrorCallback): void; }
-
-interface AsyncQueue<T> {
-    length(): number;
-    started: boolean;
-    running(): number;
-    idle(): boolean;
-    concurrency: number;
-    push(task: T, callback?: ErrorCallback): void;
-    push(task: T[], callback?: ErrorCallback): void;
-    unshift(task: T, callback?: ErrorCallback): void;
-    unshift(task: T[], callback?: ErrorCallback): void;
-    saturated: () => any;
-    empty: () => any;
-    drain: () => any;
-    paused: boolean;
-    pause(): void
-    resume(): void;
-    kill(): void;
-}
-
-interface AsyncPriorityQueue<T> {
-    length(): number;
-    concurrency: number;
-    started: boolean;
-    paused: boolean;
-    push(task: T, priority: number, callback?: AsyncResultArrayCallback<T>): void;
-    push(task: T[], priority: number, callback?: AsyncResultArrayCallback<T>): void;
-    saturated: () => any;
-    empty: () => any;
-    drain: () => any;
-    running(): number;
-    idle(): boolean;
-    pause(): void;
-    resume(): void;
-    kill(): void;
-}
-
-interface AsyncCargo {
-    length(): number;
-    payload: number;
-    push(task: any, callback? : Function): void;
-    push(task: any[], callback? : Function): void;
-    saturated(): void;
-    empty(): void;
-    drain(): void;
-    idle(): boolean;
-    pause(): void;
-    resume(): void;
-    kill(): void;
-}
-
-interface Async {
-
-    // Collections
-    each<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    eachSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    eachLimit<T>(arr: T[], limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
-    forEachOf(obj: any, iterator: (item: any, key: [string|number], callback?: ErrorCallback) => void, callback: ErrorCallback): void;
-    forEachOf<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOfSeries(obj: any, iterator: (item: any, key: [string|number], callback?: ErrorCallback) => void, callback: ErrorCallback): void;
-    forEachOfSeries<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    forEachOfLimit(obj: any, limit: number, iterator: (item: any, key: [string|number], callback?: ErrorCallback) => void, callback: ErrorCallback): void;
-    forEachOfLimit<T>(obj: T[], limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
-    map<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    mapSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    mapLimit<T, R>(arr: T[], limit: number, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
-    filter<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    select<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    filterSeries<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    selectSeries<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    filterLimit<T>(arr: T[], limit: number, iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    selectLimit<T>(arr: T[], limit: number, iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    reject<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    rejectSeries<T>(arr: T[], iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    rejectLimit<T>(arr: T[], limit: number, iterator: AsyncResultIterator<T, boolean>, callback?: (results: T[]) => any): any;
-    reduce<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    inject<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    foldl<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
-    reduceRight<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
-    foldr<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
-    detect<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
-    detectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
-    detectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
-    sortBy<T, V>(arr: T[], iterator: AsyncResultIterator<T, V>, callback?: AsyncResultArrayCallback<T>): any;
-    some<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    someLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    any<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
-    every<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    everyLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    all<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
-    concat<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
-    concatSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
-
-    // Control Flow
-    series<T>(tasks: AsyncFunction<T>[], callback?: AsyncResultArrayCallback<T>): void;
-    series<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
-    parallel<T>(tasks: Array<AsyncFunction<T>>, callback?: AsyncResultArrayCallback<T>): void;
-    parallel<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
-    parallelLimit<T>(tasks: Array<AsyncFunction<T>>, limit: number, callback?: AsyncResultArrayCallback<T>): void;
-    parallelLimit<T>(tasks: Dictionary<AsyncFunction<T>>, limit: number, callback?: AsyncResultObjectCallback<T>): void;
-    whilst(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doWhilst(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
-    until(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doUntil(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
-    during(test: (testCallback : (error: Error, truth: boolean) => void) => void, fn: AsyncVoidFunction, callback: (err: any) => void): void;
-    doDuring(fn: AsyncVoidFunction, test: (testCallback: (error: Error, truth: boolean) => void) => void, callback: (err: any) => void): void;
-    forever(next: (errCallback : (err: Error) => void) => void, errBack: (err: Error) => void) : void;
-    waterfall(tasks: Function[], callback?: (err: Error, result: any) => void): void;
-    compose(...fns: Function[]): void;
-    seq(...fns: Function[]): void;
-    applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-    applyEachSeries(fns: Function[], argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
-    queue<T>(worker: AsyncWorker<T>, concurrency?: number): AsyncQueue<T>;
-    priorityQueue<T>(worker: AsyncWorker<T>, concurrency: number): AsyncPriorityQueue<T>;
-    cargo(worker : (tasks: any[], callback : ErrorCallback) => void, payload? : number) : AsyncCargo;
-    auto(tasks: any, callback?: (error: Error, results: any) => void): void;
-    retry<T>(opts: number, task: (callback : AsyncResultCallback<T>, results: any) => void, callback: (error: Error, results: any) => void): void;
-    retry<T>(opts: { times: number, interval: number }, task: (callback: AsyncResultCallback<T>, results : any) => void, callback: (error: Error, results: any) => void): void;
-    iterator(tasks: Function[]): Function;
-    apply(fn: Function, ...arguments: any[]): AsyncFunction<any>;
-    nextTick(callback: Function): void;
-    setImmediate(callback: Function): void;
-
-    times<T> (n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
-    timesSeries<T>(n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
-    timesLimit<T>(n: number, limit: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
-
-    // Utils
-    memoize(fn: Function, hasher?: Function): Function;
-    unmemoize(fn: Function): Function;
-    ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
-    constant(...values: any[]): Function;
-    asyncify(fn: Function): Function;
-    wrapSync(fn: Function): Function;
-    log(fn: Function, ...arguments: any[]): void;
-    dir(fn: Function, ...arguments: any[]): void;
-    noConflict(): Async;
-}
-
-declare var async: Async;
-
-declare module "async" {
-    export = async;
-}
+// Type definitions for Async 1.4.2
+// Project: https://github.com/caolan/async
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Arseniy Maximov <https://github.com/kern0>, Joe Herman <https://github.com/Penryn>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+interface Dictionary<T> { [key: string]: T; }
+
+interface ErrorCallback { (err?: Error): void; }
+interface AsyncResultCallback<T> { (err: Error, result: T): void; }
+interface AsyncResultArrayCallback<T> { (err: Error, results: T[]): void; }
+interface AsyncResultObjectCallback<T> { (err: Error, results: Dictionary<T>): void; }
+
+interface AsyncFunction<T> { (callback: (err?: Error, result?: T) => void): void; }
+interface AsyncIterator<T> { (item: T, callback: ErrorCallback): void; }
+interface AsyncForEachOfIterator<T> { (item: T, key: number, callback: ErrorCallback): void; }
+interface AsyncResultIterator<T, R> { (item: T, callback: AsyncResultCallback<R>): void; }
+interface AsyncMemoIterator<T, R> { (memo: R, item: T, callback: AsyncResultCallback<R>): void; }
+interface AsyncBooleanIterator<T> { (item: T, callback: (truthValue: boolean) => void): void; }
+
+interface AsyncWorker<T> { (task: T, callback: ErrorCallback): void; }
+interface AsyncVoidFunction { (callback: ErrorCallback): void; }
+
+interface AsyncQueue<T> {
+    length(): number;
+    started: boolean;
+    running(): number;
+    idle(): boolean;
+    concurrency: number;
+    push(task: T, callback?: ErrorCallback): void;
+    push(task: T[], callback?: ErrorCallback): void;
+    unshift(task: T, callback?: ErrorCallback): void;
+    unshift(task: T[], callback?: ErrorCallback): void;
+    saturated: () => any;
+    empty: () => any;
+    drain: () => any;
+    paused: boolean;
+    pause(): void
+    resume(): void;
+    kill(): void;
+}
+
+interface AsyncPriorityQueue<T> {
+    length(): number;
+    concurrency: number;
+    started: boolean;
+    paused: boolean;
+    push(task: T, priority: number, callback?: AsyncResultArrayCallback<T>): void;
+    push(task: T[], priority: number, callback?: AsyncResultArrayCallback<T>): void;
+    saturated: () => any;
+    empty: () => any;
+    drain: () => any;
+    running(): number;
+    idle(): boolean;
+    pause(): void;
+    resume(): void;
+    kill(): void;
+}
+
+interface AsyncCargo {
+    length(): number;
+    payload: number;
+    push(task: any, callback? : Function): void;
+    push(task: any[], callback? : Function): void;
+    saturated(): void;
+    empty(): void;
+    drain(): void;
+    idle(): boolean;
+    pause(): void;
+    resume(): void;
+    kill(): void;
+}
+
+interface Async {
+
+    // Collections
+    each<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    eachSeries<T>(arr: T[], iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    eachLimit<T>(arr: T[], limit: number, iterator: AsyncIterator<T>, callback?: ErrorCallback): void;
+    forEachOf(obj: any, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
+    forEachOf<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    forEachOfSeries(obj: any, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
+    forEachOfSeries<T>(obj: T[], iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    forEachOfLimit(obj: any, limit: number, iterator: (item: any, key: string|number, callback?: ErrorCallback) => void, callback: ErrorCallback): void;
+    forEachOfLimit<T>(obj: T[], limit: number, iterator: AsyncForEachOfIterator<T>, callback?: ErrorCallback): void;
+    map<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
+    mapSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
+    mapLimit<T, R>(arr: T[], limit: number, iterator: AsyncResultIterator<T, R>, callback?: AsyncResultArrayCallback<R>): any;
+    filter<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    select<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    filterSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    selectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    filterLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    selectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    reject<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    rejectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    rejectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (results: T[]) => any): any;
+    reduce<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
+    inject<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
+    foldl<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback?: AsyncResultCallback<R>): any;
+    reduceRight<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
+    foldr<T, R>(arr: T[], memo: R, iterator: AsyncMemoIterator<T, R>, callback: AsyncResultCallback<R>): any;
+    detect<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
+    detectSeries<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
+    detectLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: T) => void): any;
+    sortBy<T, V>(arr: T[], iterator: AsyncResultIterator<T, V>, callback?: AsyncResultArrayCallback<T>): any;
+    some<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
+    someLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
+    any<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => void): any;
+    every<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
+    everyLimit<T>(arr: T[], limit: number, iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
+    all<T>(arr: T[], iterator: AsyncBooleanIterator<T>, callback?: (result: boolean) => any): any;
+    concat<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
+    concatSeries<T, R>(arr: T[], iterator: AsyncResultIterator<T, R[]>, callback?: AsyncResultArrayCallback<R>): any;
+
+    // Control Flow
+    series<T>(tasks: AsyncFunction<T>[], callback?: AsyncResultArrayCallback<T>): void;
+    series<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
+    parallel<T>(tasks: Array<AsyncFunction<T>>, callback?: AsyncResultArrayCallback<T>): void;
+    parallel<T>(tasks: Dictionary<AsyncFunction<T>>, callback?: AsyncResultObjectCallback<T>): void;
+    parallelLimit<T>(tasks: Array<AsyncFunction<T>>, limit: number, callback?: AsyncResultArrayCallback<T>): void;
+    parallelLimit<T>(tasks: Dictionary<AsyncFunction<T>>, limit: number, callback?: AsyncResultObjectCallback<T>): void;
+    whilst(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
+    doWhilst(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
+    until(test: () => boolean, fn: AsyncVoidFunction, callback: (err: any) => void): void;
+    doUntil(fn: AsyncVoidFunction, test: () => boolean, callback: (err: any) => void): void;
+    during(test: (testCallback : (error: Error, truth: boolean) => void) => void, fn: AsyncVoidFunction, callback: (err: any) => void): void;
+    doDuring(fn: AsyncVoidFunction, test: (testCallback: (error: Error, truth: boolean) => void) => void, callback: (err: any) => void): void;
+    forever(next: (errCallback : (err: Error) => void) => void, errBack: (err: Error) => void) : void;
+    waterfall(tasks: Function[], callback?: (err: Error, results?: any) => void): void;
+    compose(...fns: Function[]): void;
+    seq(...fns: Function[]): void;
+    applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+    applyEachSeries(fns: Function[], argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
+    queue<T>(worker: AsyncWorker<T>, concurrency?: number): AsyncQueue<T>;
+    priorityQueue<T>(worker: AsyncWorker<T>, concurrency: number): AsyncPriorityQueue<T>;
+    cargo(worker : (tasks: any[], callback : ErrorCallback) => void, payload? : number) : AsyncCargo;
+    auto(tasks: any, callback?: (error: Error, results: any) => void): void;
+    retry<T>(opts: number, task: (callback : AsyncResultCallback<T>, results: any) => void, callback: (error: Error, results: any) => void): void;
+    retry<T>(opts: { times: number, interval: number }, task: (callback: AsyncResultCallback<T>, results : any) => void, callback: (error: Error, results: any) => void): void;
+    iterator(tasks: Function[]): Function;
+    apply(fn: Function, ...arguments: any[]): AsyncFunction<any>;
+    nextTick(callback: Function): void;
+    setImmediate(callback: Function): void;
+
+    times<T> (n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
+    timesSeries<T>(n: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
+    timesLimit<T>(n: number, limit: number, iterator: AsyncResultIterator<number, T>, callback: AsyncResultArrayCallback<T>): void;
+
+    // Utils
+    memoize(fn: Function, hasher?: Function): Function;
+    unmemoize(fn: Function): Function;
+    ensureAsync(fn: (... argsAndCallback: any[]) => void): Function;
+    constant(...values: any[]): Function;
+    asyncify(fn: Function): Function;
+    wrapSync(fn: Function): Function;
+    log(fn: Function, ...arguments: any[]): void;
+    dir(fn: Function, ...arguments: any[]): void;
+    noConflict(): Async;
+}
+
+declare var async: Async;
+
+declare module "async" {
+    export = async;
+}

aws-sdk/aws-sdk-tests.ts

@@ -1,13 +1,256 @@
 /// <reference path="aws-sdk.d.ts" />
 
-import awsSdk = require('aws-sdk');
+import AWS = require('aws-sdk');
 
 var str: string;
 
-var creds: awsSdk.Credentials;
+var creds: AWS.Credentials;
 
-creds = new awsSdk.Credentials(str, str);
-creds = new awsSdk.Credentials(str, str, str);
+creds = new AWS.Credentials(str, str);
+creds = new AWS.Credentials(str, str, str);
 str = creds.accessKeyId;
 
-// more
+
+/*
+ * SQS 
+ */
+var sqs:AWS.SQS
+
+//Default constructor
+sqs = new AWS.SQS();
+
+//Locking the API Version
+sqs = new AWS.SQS({apiVersion: '2012-11-05'});
+
+// Locking the API Version Globally
+AWS.config.apiVersions = {
+  sqs: '2012-11-05',
+  // other service API versions
+};
+
+sqs.addPermission({
+	AWSAccountIds: [ /* required */
+		'STRING_VALUE',
+		/* more items */
+	],
+	Actions: [ /* required */
+		'STRING_VALUE',
+		/* more items */
+	],
+	Label: 'STRING_VALUE', /* required */
+	QueueUrl: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.changeMessageVisibility({
+		QueueUrl: 'STRING_VALUE', /* required */
+		ReceiptHandle: 'STRING_VALUE', /* required */
+		VisibilityTimeout: 0 /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.changeMessageVisibilityBatch({
+		Entries: [ /* required */
+			{
+				Id: 'STRING_VALUE', /* required */
+				ReceiptHandle: 'STRING_VALUE', /* required */
+				VisibilityTimeout: 0
+			},
+			/* more items */
+		],
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.createQueue({
+		QueueName: 'STRING_VALUE', /* required */
+		Attributes: {
+			someKey: 'STRING_VALUE',
+			/* anotherKey: ... */
+		}
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+
+sqs.deleteMessage({
+		QueueUrl: 'STRING_VALUE', /* required */
+		ReceiptHandle: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.deleteMessageBatch({
+		Entries: [ /* required */
+			{
+			Id: 'STRING_VALUE', /* required */
+			ReceiptHandle: 'STRING_VALUE' /* required */
+			},
+			/* more items */
+		],
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.deleteQueue({
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.getQueueAttributes({
+		QueueUrl: 'STRING_VALUE', /* required */
+		AttributeNames: [
+			'Policy | VisibilityTimeout | MaximumMessageSize | MessageRetentionPeriod | ApproximateNumberOfMessages | ApproximateNumberOfMessagesNotVisible | CreatedTimestamp | LastModifiedTimestamp | QueueArn | ApproximateNumberOfMessagesDelayed | DelaySeconds | ReceiveMessageWaitTimeSeconds | RedrivePolicy',
+			/* more items */
+		]
+	},
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.getQueueUrl({
+		QueueName: 'STRING_VALUE', /* required */
+		QueueOwnerAWSAccountId: 'STRING_VALUE'
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.listDeadLetterSourceQueues({
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+	
+sqs.listQueues({
+		QueueNamePrefix: 'STRING_VALUE'
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else     console.log(data);           // successful response
+	});
+
+sqs.purgeQueue({
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.receiveMessage({
+		QueueUrl: 'STRING_VALUE', /* required */
+		AttributeNames: [
+			'Policy | VisibilityTimeout | MaximumMessageSize | MessageRetentionPeriod | ApproximateNumberOfMessages | ApproximateNumberOfMessagesNotVisible | CreatedTimestamp | LastModifiedTimestamp | QueueArn | ApproximateNumberOfMessagesDelayed | DelaySeconds | ReceiveMessageWaitTimeSeconds | RedrivePolicy',
+			/* more items */
+		],
+		MaxNumberOfMessages: 0,
+		MessageAttributeNames: [
+			'STRING_VALUE',
+			/* more items */
+		],
+		VisibilityTimeout: 0,
+		WaitTimeSeconds: 0
+	}, function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.removePermission({
+		Label: 'STRING_VALUE', /* required */
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.sendMessage({
+		MessageBody: 'STRING_VALUE', /* required */
+		QueueUrl: 'STRING_VALUE', /* required */
+		DelaySeconds: 0,
+		MessageAttributes: {
+			someKey: {
+				DataType: 'STRING_VALUE', /* required */
+				BinaryListValues: [
+					new Buffer('...') || 'STRING_VALUE',
+					/* more items */
+				],
+				BinaryValue: new Buffer('...') || 'STRING_VALUE',
+				StringListValues: [
+					'STRING_VALUE',
+					/* more items */
+				],
+				StringValue: 'STRING_VALUE'
+			},
+			/* anotherKey: ... */
+		}
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+
+sqs.sendMessageBatch({
+		Entries: [ /* required */
+			{
+				Id: 'STRING_VALUE', /* required */
+				MessageBody: 'STRING_VALUE', /* required */
+				DelaySeconds: 0,
+				MessageAttributes: {
+					someKey: {
+						DataType: 'STRING_VALUE', /* required */
+						BinaryListValues: [
+							new Buffer('...') ,
+							/* more items */
+						],
+						BinaryValue: new Buffer('...'),
+						StringListValues: [
+							'STRING_VALUE',
+							/* more items */
+						],
+						StringValue: 'STRING_VALUE'
+					},
+					/* anotherKey: ... */
+				}
+			},
+			/* more items */
+		],
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, 
+	function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+sqs.setQueueAttributes({
+		Attributes: { /* required */
+			someKey: 'STRING_VALUE',
+			/* anotherKey: ... */
+		},
+		QueueUrl: 'STRING_VALUE' /* required */
+	}, function(err, data) {
+		if (err) console.log(err, err.stack); // an error occurred
+		else console.log(data);           // successful response
+	});
+	
+	

aws-sdk/aws-sdk-tests.ts.tscparams

@@ -0,0 +1 @@
+--noImplicitAny --module commonjs --target es5 

aws-sdk/aws-sdk.d.ts

@@ -30,6 +30,16 @@ declare module "aws-sdk" {
 		xhrAsync?: boolean;
 		xhrWithCredentials?: boolean;
 	}
+	
+	export class Endpoint {
+		constructor(endpoint:string);
+		
+		host:string;
+		hostname:string;
+		href:string;
+		port:number;
+		protocol:string;
+	}
 
 	export interface Services {
 		autoscaling?: any;
@@ -99,7 +109,25 @@ declare module "aws-sdk" {
 
 	export class SQS {
 		constructor(options?: any);
-		public client: Sqs.Client;
+		endpoint:Endpoint;
+		
+		addPermission(params: SQS.AddPermissionParams, callback: (err:Error, data:any) => void): void;
+		changeMessageVisibility(params: SQS.ChangeMessageVisibilityParams, callback: (err:Error, data:any) => void): void;
+		changeMessageVisibilityBatch(params: SQS.ChangeMessageVisibilityBatchParams, callback: (err:Error, data:SQS.ChangeMessageVisibilityBatchResponse) => void): void;
+		createQueue(params: SQS.CreateQueueParams, callback: (err: Error, data: SQS.CreateQueueResult) => void): void;
+		deleteMessage(params: SQS.DeleteMessageParams, callback: (err: Error, data: any) => void): void;
+		deleteMessageBatch(params: SQS.DeleteMessageBatchParams, callback: (err: Error, data: SQS.DeleteMessageBatchResult) => void): void;
+		deleteQueue(params: { QueueUrl: string; }, callback: (err: Error, data: any) => void): void;
+		getQueueAttributes(params: SQS.GetQueueAttributesParams, callback: (err: Error, data: SQS.GetQueueAttributesResult) => void): void;
+		getQueueUrl(params: SQS.GetQueueUrlParams, callback: (err: Error, data: { QueueUrl: string; }) => void): void;
+		listDeadLetterSourceQueues(params: {QueueUrl:string}, callback: (err: Error, data: {queueUrls: string[]}) => void): void;
+		listQueues(params: {QueueNamePrefix?:string}, callback: (err: Error, data: {QueueUrls: string[]}) => void): void;
+		purgeQueue(params: {QueueUrl: string}, callback: (err: Error, data: any) => void): void;
+		receiveMessage(params: SQS.ReceiveMessageParams, callback: (err: Error, data: SQS.ReceiveMessageResult) => void): void;
+		removePermission(params: {QueueUrl: string, Label: string}, callback: (err: Error, data: any) => void): void;
+		sendMessage(params: SQS.SendMessageParams, callback: (err: Error, data: SQS.SendMessageResult) => void): void;
+		sendMessageBatch(params: SQS.SendMessageBatchParams, callback: (err: Error, data: SQS.SendMessageBatchResult) => void): void;
+		setQueueAttributes(params: SQS.SetQueueAttributesParams, callback: (err: Error, data: any) => void): void;			
 	}
 
 	export class SES {
@@ -126,36 +154,77 @@ declare module "aws-sdk" {
 		constructor(options?: any);
 	}
 
-	export module Sqs {
-
-		export interface Client {
-			config: ClientConfig;
-
-			sendMessage(params: SendMessageRequest, callback: (err: any, data: SendMessageResult) => void): void;
-			sendMessageBatch(params: SendMessageBatchRequest, callback: (err: any, data: SendMessageBatchResult) => void): void;
-			receiveMessage(params: ReceiveMessageRequest, callback: (err: any, data: ReceiveMessageResult) => void): void;
-			deleteMessage(params: DeleteMessageRequest, callback: (err: any, data: any) => void): void;
-			deleteMessageBatch(params: DeleteMessageBatchRequest, callback: (err: any, data: DeleteMessageBatchResult) => void): void;
-			createQueue(params: CreateQueueRequest, callback: (err: any, data: CreateQueueResult) => void): void;
-			deleteQueue(params: DeleteQueueRequest, callback: (err: any, data: any) => void): void;
+	export module SQS {
+		
+		export interface SqsOptions {
+			params?: any;
+			endpoint?: string;
+			accessKeyId?: string;
+			secretAccessKey?: string;
+			sessionToken?: Credentials;
+			credentials?: Credentials;
+			credentialProvider?: any;
+			region?: string;
+			maxRetries?: number;
+			maxRedirects?: number;
+			sslEnabled?: boolean;
+			paramValidation?: boolean;
+			computeChecksums?: boolean;
+			convertResponseTypes?: boolean;
+			correctClockSkew?: boolean;
+			s3ForcePathStyle?: boolean;
+			s3BucketEndpoint?: boolean;
+			httpOptions?: HttpOptions;
+			apiVersion?: string;
+			apiVersions?: { [serviceName:string]: string};
+			logger?: Logger;
+			systemClockOffset?: number;
+			signatureVersion?: string;
+			signatureCache?: boolean;
+		}
+		
+		export interface AddPermissionParams {
+			QueueUrl: string;
+			Label: string;
+			AWSAccountIds:string[];
+			Actions:string[];
+		}
+		
+		export interface ChangeMessageVisibilityParams { 
+			QueueUrl: string, 
+			ReceiptHandle: string, 
+			VisibilityTimeout: number 
+		}
+		
+		export interface ChangeMessageVisibilityBatchParams { 
+			QueueUrl: string, 
+			Entries: { Id: string; ReceiptHandle: string; VisibilityTimeout?: number; }[]
+		}
+		
+		export interface ChangeMessageVisibilityBatchResponse {
+			Successful: { Id:string }[];
+			Failed: BatchResultErrorEntry[];
 		}
 
-		export interface SendMessageRequest {
-			QueueUrl?: string;
-			MessageBody?: string;
+		export interface SendMessageParams {
+			QueueUrl: string;
+			MessageBody: string;
 			DelaySeconds?: number;
+			MessageAttributes?: { [name:string]: MessageAttribute; }
 		}
 
-		export interface ReceiveMessageRequest {
-			QueueUrl?: string;
+		export interface ReceiveMessageParams {
+			QueueUrl: string;
 			MaxNumberOfMessages?: number;
 			VisibilityTimeout?: number;
 			AttributeNames?: string[];
+			MessageAttributeNames?: string[];
+			WaitTimeSeconds?:number;
 		}
 
-		export interface DeleteMessageBatchRequest {
-			QueueUrl?: string;
-			Entries?: DeleteMessageBatchRequestEntry[];
+		export interface DeleteMessageBatchParams {
+			QueueUrl: string;
+			Entries: DeleteMessageBatchRequestEntry[];
 		}
 
 		export interface DeleteMessageBatchRequestEntry {
@@ -163,85 +232,117 @@ declare module "aws-sdk" {
 			ReceiptHandle: string;
 		}
 
-		export interface DeleteMessageRequest {
-			QueueUrl?: string;
-			ReceiptHandle?: string;
+		export interface DeleteMessageParams {
+			QueueUrl: string;
+			ReceiptHandle: string;
 		}
 
-		export class Attribute {
-			Name: string;
-			Value: string;
+		export interface SendMessageBatchParams {
+			QueueUrl: string;
+			Entries: SendMessageBatchRequestEntry[];
 		}
 
-		export interface SendMessageBatchRequest {
-			QueueUrl?: string;
-			Entries?: SendMessageBatchRequestEntry[];
-		}
-
-		export class SendMessageBatchRequestEntry {
+		export interface SendMessageBatchRequestEntry {
 			Id: string;
 			MessageBody: string;
-			DelaySeconds: number;
-		}
-
-		export interface CreateQueueRequest {
-			QueueName?: string;
-			DefaultVisibilityTimeout?: number;
 			DelaySeconds?: number;
-			Attributes?: Attribute[];
+			MessageAttributes?: { [name:string]: MessageAttribute; }
 		}
 
-		export interface DeleteQueueRequest {
-			QueueUrl?: string;
+		export interface CreateQueueParams {
+			QueueName: string;
+			Attributes: QueueAttributes;
 		}
-
-		export class SendMessageResult {
+		
+		export interface QueueAttributes {
+			[name:string]: any;
+			DelaySeconds?: number;
+			MaximumMessageSize?: number;
+			MessageRetentionPeriod?: number;
+			Policy?: any;
+			ReceiveMessageWaitTimeSeconds?: number;
+			VisibilityTimeout?: number;
+			RedrivePolicy?: any;
+		}
+		
+		export interface GetQueueAttributesParams {
+			QueueUrl: string;
+			AttributeNames: string[];
+		}
+		
+		export interface GetQueueAttributesResult {
+			Attributes: {[name:string]: string};
+		}
+		
+		export interface GetQueueUrlParams {
+			QueueName: string;
+			QueueOwnerAWSAccountId?: string;
+		}
+		
+		export interface SendMessageResult {
 			MessageId: string;
 			MD5OfMessageBody: string;
+			MD5OfMessageAttributes: string;
 		}
 
-		export class ReceiveMessageResult {
+		export interface ReceiveMessageResult {
 			Messages: Message[];
 		}
 
-		export class Message {
+		export interface Message {
 			MessageId: string;
 			ReceiptHandle: string;
 			MD5OfBody: string;
 			Body: string;
-			Attributes: Attribute[];
+			Attributes: { [name:string]:any };
+			MD5OfMessageAttributes:string;
+			MessageAttributes: { [name:string]: MessageAttribute; }
 		}
 
-		export class DeleteMessageBatchResult {
+		export interface MessageAttribute {
+			StringValue?: string;
+			BinaryValue?: any; //(Buffer, Typed Array, Blob, String) 
+			StringListValues?: string[];
+			BinaryListValues?: any[];
+			DataType: string;
+		}
+				
+		export interface DeleteMessageBatchResult {
 			Successful: DeleteMessageBatchResultEntry[];
 			Failed: BatchResultErrorEntry[];
 		}
 
-		export class DeleteMessageBatchResultEntry {
+		export interface DeleteMessageBatchResultEntry {
 			Id: string;
 		}
 
-		export class BatchResultErrorEntry {
+		export interface BatchResultErrorEntry {
 			Id: string;
 			Code: string;
-			Message: string;
-			SenderFault: string;
+			Message?: string;
+			SenderFault: boolean;
 		}
 
-		export class SendMessageBatchResult {
+		export interface SendMessageBatchResult {
 			Successful: SendMessageBatchResultEntry[];
 			Failed: BatchResultErrorEntry[];
 		}
 
-		export class SendMessageBatchResultEntry {
+		export interface SendMessageBatchResultEntry {
 			Id: string;
 			MessageId: string;
 			MD5OfMessageBody: string;
+			MD5OfMessageAttributes:string;
 		}
 
-		export class CreateQueueResult {
+		export interface CreateQueueResult {
 			QueueUrl: string;
 		}
+		
+		export interface SetQueueAttributesParams {
+			QueueUrl: string;
+			Attributes: QueueAttributes;
+		}
 
 	}
 

backbone/backbone-global.d.ts

@@ -0,0 +1,390 @@
+// Type definitions for Backbone 1.0.0
+// Project: http://backbonejs.org/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Natan Vivo <https://github.com/nvivo/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+declare module Backbone {
+
+    interface AddOptions extends Silenceable {
+        at?: number;
+    }
+
+    interface HistoryOptions extends Silenceable {
+        pushState?: boolean;
+        root?: string;
+    }
+
+    interface NavigateOptions {
+        trigger?: boolean;
+        replace?: boolean;
+    }
+
+    interface RouterOptions {
+        routes: any;
+    }
+
+    interface Silenceable {
+        silent?: boolean;
+    }
+
+    interface Validable {
+        validate?: boolean;
+    }
+
+    interface Waitable {
+        wait?: boolean;
+    }
+
+    interface Parseable {
+        parse?: any;
+    }
+
+    interface PersistenceOptions {
+        url?: string;
+        beforeSend?: (jqxhr: JQueryXHR) => void;
+        success?: (modelOrCollection?: any, response?: any, options?: any) => void;
+        error?: (modelOrCollection?: any, jqxhr?: JQueryXHR, options?: any) => void;
+    }
+
+    interface ModelSetOptions extends Silenceable, Validable {
+    }
+
+    interface ModelFetchOptions extends PersistenceOptions, ModelSetOptions, Parseable {
+    }
+
+    interface ModelSaveOptions extends Silenceable, Waitable, Validable, Parseable, PersistenceOptions {
+        patch?: boolean;
+    }
+
+    interface ModelDestroyOptions extends Waitable, PersistenceOptions {
+    }
+
+    interface CollectionFetchOptions extends PersistenceOptions, Parseable {
+        reset?: boolean;
+    }
+
+    interface ObjectHash {
+        [key: string]: any;
+    }
+
+    interface RoutesHash {
+        [routePattern: string]: string | {(...urlParts: string[]): void};
+    }
+
+    interface EventsHash {
+        [selector: string]: string | {(eventObject: JQueryEventObject): void};
+    }
+
+    class Events {
+        on(eventName: string, callback?: Function, context?: any): any;
+        on(eventMap: EventsHash): any;
+        off(eventName?: string, callback?: Function, context?: any): any;
+        trigger(eventName: string, ...args: any[]): any;
+        bind(eventName: string, callback: Function, context?: any): any;
+        unbind(eventName?: string, callback?: Function, context?: any): any;
+
+        once(events: string, callback: Function, context?: any): any;
+        listenTo(object: any, events: string, callback: Function): any;
+        listenToOnce(object: any, events: string, callback: Function): any;
+        stopListening(object?: any, events?: string, callback?: Function): any;
+    }
+
+    class ModelBase extends Events {
+        url: any;
+        parse(response: any, options?: any): any;
+        toJSON(options?: any): any;
+        sync(...arg: any[]): JQueryXHR;
+    }
+
+    class Model extends ModelBase {
+
+        /**
+        * Do not use, prefer TypeScript's extend functionality.
+        **/
+        private static extend(properties: any, classProperties?: any): any;
+
+        attributes: any;
+        changed: any[];
+        cid: string;
+        collection: Collection<any>;
+
+        /**
+        * Default attributes for the model. It can be an object hash or a method returning an object hash.
+        * For assigning an object hash, do it like this: this.defaults = <any>{ attribute: value, ... };
+        * That works only if you set it in the constructor or the initialize method.
+        **/
+        defaults(): ObjectHash;
+        id: any;
+        idAttribute: string;
+        validationError: any;
+        urlRoot: any;
+
+        constructor(attributes?: any, options?: any);
+        initialize(attributes?: any, options?: any): void;
+
+        fetch(options?: ModelFetchOptions): JQueryXHR;
+
+        /**
+        * For strongly-typed access to attributes, use the `get` method only privately in public getter properties.
+        * @example
+        * get name(): string {
+        *    return super.get("name");
+        * }
+        **/
+        /*private*/ get(attributeName: string): any;
+
+        /**
+        * For strongly-typed assignment of attributes, use the `set` method only privately in public setter properties.
+        * @example
+        * set name(value: string) {
+        *    super.set("name", value);
+        * }
+        **/
+        /*private*/ set(attributeName: string, value: any, options?: ModelSetOptions): Model;
+        set(obj: any, options?: ModelSetOptions): Model;
+
+        change(): any;
+        changedAttributes(attributes?: any): any[];
+        clear(options?: Silenceable): any;
+        clone(): Model;
+        destroy(options?: ModelDestroyOptions): any;
+        escape(attribute: string): string;
+        has(attribute: string): boolean;
+        hasChanged(attribute?: string): boolean;
+        isNew(): boolean;
+        isValid(options?:any): boolean;
+        previous(attribute: string): any;
+        previousAttributes(): any[];
+        save(attributes?: any, options?: ModelSaveOptions): any;
+        unset(attribute: string, options?: Silenceable): Model;
+        validate(attributes: any, options?: any): any;
+
+        private _validate(attributes: any, options: any): boolean;
+
+        // mixins from underscore
+
+        keys(): string[];
+        values(): any[];
+        pairs(): any[];
+        invert(): any;
+        pick(keys: string[]): any;
+        pick(...keys: string[]): any;
+        omit(keys: string[]): any;
+        omit(...keys: string[]): any;
+    }
+
+    class Collection<TModel extends Model> extends ModelBase {
+
+        /**
+        * Do not use, prefer TypeScript's extend functionality.
+        **/
+        private static extend(properties: any, classProperties?: any): any;
+
+        model: new (...args:any[]) => TModel;
+        models: TModel[];
+        length: number;
+
+        constructor(models?: TModel[] | Object[], options?: any);
+        initialize(models?: TModel[] | Object[], options?: any): void;
+
+        fetch(options?: CollectionFetchOptions): JQueryXHR;
+
+        comparator(element: TModel): number;
+        comparator(compare: TModel, to?: TModel): number;
+
+        add(model: {}|TModel, options?: AddOptions): TModel;
+        add(models: ({}|TModel)[], options?: AddOptions): TModel[];
+        at(index: number): TModel;
+        /**
+         * Get a model from a collection, specified by an id, a cid, or by passing in a model.
+         **/
+        get(id: number|string|Model): TModel;
+        create(attributes: any, options?: ModelSaveOptions): TModel;
+        pluck(attribute: string): any[];
+        push(model: TModel, options?: AddOptions): TModel;
+        pop(options?: Silenceable): TModel;
+        remove(model: TModel, options?: Silenceable): TModel;
+        remove(models: TModel[], options?: Silenceable): TModel[];
+        reset(models?: TModel[], options?: Silenceable): TModel[];
+        set(models?: TModel[], options?: Silenceable): TModel[];
+        shift(options?: Silenceable): TModel;
+        sort(options?: Silenceable): Collection<TModel>;
+        unshift(model: TModel, options?: AddOptions): TModel;
+        where(properties: any): TModel[];
+        findWhere(properties: any): TModel;
+
+        private _prepareModel(attributes?: any, options?: any): any;
+        private _removeReference(model: TModel): void;
+        private _onModelEvent(event: string, model: TModel, collection: Collection<TModel>, options: any): void;
+
+        // mixins from underscore
+
+        all(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
+        any(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
+        collect(iterator: (element: TModel, index: number, context?: any) => any[], context?: any): any[];
+        chain(): any;
+        contains(value: any): boolean;
+        countBy(iterator: (element: TModel, index: number) => any): _.Dictionary<number>;
+        countBy(attribute: string): _.Dictionary<number>;
+        detect(iterator: (item: any) => boolean, context?: any): any; // ???
+        drop(): TModel;
+        drop(n: number): TModel[];
+        each(iterator: (element: TModel, index: number, list?: any) => void, context?: any): any;
+        every(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
+        filter(iterator: (element: TModel, index: number) => boolean, context?: any): TModel[];
+        find(iterator: (element: TModel, index: number) => boolean, context?: any): TModel;
+        first(): TModel;
+        first(n: number): TModel[];
+        foldl(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
+        forEach(iterator: (element: TModel, index: number, list?: any) => void, context?: any): any;
+        groupBy(iterator: (element: TModel, index: number) => string, context?: any): _.Dictionary<TModel[]>;
+        groupBy(attribute: string, context?: any): _.Dictionary<TModel[]>;
+        include(value: any): boolean;
+        indexOf(element: TModel, isSorted?: boolean): number;
+        initial(): TModel;
+        initial(n: number): TModel[];
+        inject(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
+        isEmpty(object: any): boolean;
+        invoke(methodName: string, args?: any[]): any;
+        last(): TModel;
+        last(n: number): TModel[];
+        lastIndexOf(element: TModel, fromIndex?: number): number;
+        map(iterator: (element: TModel, index: number, context?: any) => any, context?: any): any[];
+        max(iterator?: (element: TModel, index: number) => any, context?: any): TModel;
+        min(iterator?: (element: TModel, index: number) => any, context?: any): TModel;
+        reduce(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
+        select(iterator: any, context?: any): any[];
+        size(): number;
+        shuffle(): any[];
+        slice(min: number, max?: number): TModel[];
+        some(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
+        sortBy(iterator: (element: TModel, index: number) => number, context?: any): TModel[];
+        sortBy(attribute: string, context?: any): TModel[];
+        sortedIndex(element: TModel, iterator?: (element: TModel, index: number) => number): number;
+        reduceRight(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any[];
+        reject(iterator: (element: TModel, index: number) => boolean, context?: any): TModel[];
+        rest(): TModel;
+        rest(n: number): TModel[];
+        tail(): TModel;
+        tail(n: number): TModel[];
+        toArray(): any[];
+        without(...values: any[]): TModel[];
+    }
+
+    class Router extends Events {
+
+        /**
+        * Do not use, prefer TypeScript's extend functionality.
+        **/
+        private static extend(properties: any, classProperties?: any): any;
+
+        /**
+        * Routes hash or a method returning the routes hash that maps URLs with parameters to methods on your Router.
+        * For assigning routes as object hash, do it like this: this.routes = <any>{ "route": callback, ... };
+        * That works only if you set it in the constructor or the initialize method.
+        **/
+        routes: RoutesHash | any;
+
+        constructor(options?: RouterOptions);
+        initialize(options?: RouterOptions): void;
+        route(route: string|RegExp, name: string, callback?: Function): Router;
+        navigate(fragment: string, options?: NavigateOptions): Router;
+        navigate(fragment: string, trigger?: boolean): Router;
+
+        private _bindRoutes(): void;
+        private _routeToRegExp(route: string): RegExp;
+        private _extractParameters(route: RegExp, fragment: string): string[];
+    }
+
+    var history: History;
+
+    class History extends Events {
+
+        handlers: any[];
+        interval: number;
+
+        start(options?: HistoryOptions): boolean;
+
+        getHash(window?: Window): string;
+        getFragment(fragment?: string, forcePushState?: boolean): string;
+        stop(): void;
+        route(route: string, callback: Function): number;
+        checkUrl(e?: any): void;
+        loadUrl(fragmentOverride: string): boolean;
+        navigate(fragment: string, options?: any): boolean;
+        static started: boolean;
+        options: any;
+
+        private _updateHash(location: Location, fragment: string, replace: boolean): void;
+    }
+
+   interface ViewOptions<TModel extends Model> {
+      model?: TModel;
+       // TODO: quickfix, this can't be fixed easy. The collection does not need to have the same model as the parent view.
+      collection?: Backbone.Collection<any>; //was: Collection<TModel>;
+      el?: any;
+      id?: string;
+      className?: string;
+      tagName?: string;
+      attributes?: {[id: string]: any};
+    }
+
+    class View<TModel extends Model> extends Events {
+
+        /**
+        * Do not use, prefer TypeScript's extend functionality.
+        **/
+        private static extend(properties: any, classProperties?: any): any;
+
+        constructor(options?: ViewOptions<TModel>);
+        initialize(options?: ViewOptions<TModel>): void;
+
+        /**
+        * Events hash or a method returning the events hash that maps events/selectors to methods on your View.
+        * For assigning events as object hash, do it like this: this.events = <any>{ "event:selector": callback, ... };
+        * That works only if you set it in the constructor or the initialize method.
+        **/
+        events(): EventsHash;
+
+        $(selector: string): JQuery;
+        model: TModel;
+        collection: Collection<TModel>;
+        //template: (json, options?) => string;
+        setElement(element: HTMLElement|JQuery, delegate?: boolean): View<TModel>;
+        id: string;
+        cid: string;
+        className: string;
+        tagName: string;
+
+        el: any;
+        $el: JQuery;
+        setElement(element: any): View<TModel>;
+        attributes: any;
+        $(selector: any): JQuery;
+        render(): View<TModel>;
+        remove(): View<TModel>;
+        make(tagName: any, attributes?: any, content?: any): any;
+        delegateEvents(events?: EventsHash): any;
+        delegate(eventName: string, selector: string, listener: Function): View<TModel>;
+        undelegateEvents(): any;
+        undelegate(eventName: string, selector?: string, listener?: Function): View<TModel>;
+
+        _ensureElement(): void;
+    }
+
+    // SYNC
+    function sync(method: string, model: Model, options?: JQueryAjaxSettings): any;
+    function ajax(options?: JQueryAjaxSettings): JQueryXHR;
+    var emulateHTTP: boolean;
+    var emulateJSON: boolean;
+
+    // Utility
+    function noConflict(): typeof Backbone;
+    var $: JQueryStatic;
+}
+
+declare module "backbone" {
+    export = Backbone;
+}

backbone/backbone-global.d.ts.tscparams

@@ -0,0 +1 @@
+--noImplicitAny ./underscore/underscore.d.ts

backbone/backbone-with-lodash-tests.ts

@@ -0,0 +1,314 @@
+/// <reference path="../jquery/jquery.d.ts" />
+/// <reference path="../lodash/lodash.d.ts" />
+/// <reference path="./backbone-global.d.ts" />
+
+function test_events() {
+
+    var object = new Backbone.Events();
+    object.on("alert", (eventName: string) => alert("Triggered " + eventName));
+
+    object.trigger("alert", "an event");
+
+    var onChange = () => alert('whatever');
+    var context: any;
+
+    object.off("change", onChange);
+    object.off("change");
+    object.off(null, onChange);
+    object.off(null, null, context);
+    object.off();
+}
+
+class SettingDefaults extends Backbone.Model {
+
+    // 'defaults' could be set in one of the following ways:
+
+    defaults() {
+        return {
+            name: "Joe"
+        }
+    }
+
+    constructor(attributes?: any, options?: any) {
+        this.defaults = <any>{
+            name: "Joe"
+        }
+        // super has to come last
+        super(attributes, options);
+    }
+
+    // or set it like this
+    initialize() {
+        this.defaults = <any>{
+            name: "Joe"
+        }
+
+    }
+
+    // same patterns could be used for setting 'Router.routes' and 'View.events'
+}
+
+class Sidebar extends Backbone.Model {
+
+    promptColor() {
+        var cssColor = prompt("Please enter a CSS color:");
+        this.set({ color: cssColor });
+    }
+}
+
+class Note extends Backbone.Model {
+    initialize() { }
+    author() { }
+    coordinates() { }
+    allowedToEdit(account: any) {
+        return true;
+    }
+}
+
+class PrivateNote extends Note {
+    allowedToEdit(account: any) {
+        return account.owns(this);
+    }
+
+    set(attributes: any, options?: any): Backbone.Model {
+        return Backbone.Model.prototype.set.call(this, attributes, options);
+    }
+}
+
+function test_models() {
+
+    var sidebar = new Sidebar();
+    sidebar.on('change:color', (model: {}, color: string) => $('#sidebar').css({ background: color }));
+    sidebar.set({ color: 'white' });
+    sidebar.promptColor();
+
+    //////////
+
+    var note = new PrivateNote();
+
+    note.get("title");
+
+    note.set({ title: "March 20", content: "In his eyes she eclipses..." });
+
+    note.set("title", "A Scandal in Bohemia");
+}
+
+class Employee extends Backbone.Model {
+    reports: EmployeeCollection;
+
+    constructor(attributes?: any, options?: any) {
+        super(options);
+        this.reports = new EmployeeCollection();
+        this.reports.url = '../api/employees/' + this.id + '/reports';
+    }
+
+    more() {
+        this.reports.reset();
+    }
+}
+
+class EmployeeCollection extends Backbone.Collection<Employee> {
+    findByName(key: any) { }
+}
+
+class Book extends Backbone.Model {
+    title: string;
+    author: string;
+    published: boolean;
+}
+
+class Library extends Backbone.Collection<Book> {
+    // This model definition is here only to test type compatibility of the model, but it
+    // is not necessary in working code as it is automatically inferred through generics.
+    model: typeof Book;
+}
+
+class Books extends Backbone.Collection<Book> { }
+
+function test_collection() {
+
+    var books = new Books();
+
+    var book1: Book = new Book({ title: "Title 1", author: "Mike" });
+    books.add(book1);
+
+    // Objects can be added to collection by casting to model type.
+    // Compiler will check if object properties are valid for the cast.
+    // This gives better type checking than declaring an `any` overload.
+    books.add(<Book>{ title: "Title 2", author: "Mikey" });
+
+    var model: Book = book1.collection.first();
+    if (model !== book1) {
+        throw new Error("Error");
+    }
+
+    books.each(book =>
+        book.get("title"));
+
+    var titles = books.map(book =>
+        book.get("title"));
+
+    var publishedBooks = books.filter(book =>
+        book.get("published") === true);
+
+    var alphabetical = books.sortBy((book: Book): number => null);
+}
+
+//////////
+
+Backbone.history.start();
+
+module v1Changes {
+    module events {
+        function test_once() {
+            var model = new Employee;
+            model.once('invalid', () => { }, this);
+            model.once('invalid', () => { });
+        }
+
+        function test_listenTo() {
+            var model = new Employee;
+            var view = new Backbone.View<Employee>();
+            view.listenTo(model, 'invalid', () => { });
+        }
+
+        function test_listenToOnce() {
+            var model = new Employee;
+            var view = new Backbone.View<Employee>();
+            view.listenToOnce(model, 'invalid', () => { });
+        }
+
+        function test_stopListening() {
+            var model = new Employee;
+            var view = new Backbone.View<Employee>();
+            view.stopListening(model, 'invalid', () => { });
+            view.stopListening(model, 'invalid');
+            view.stopListening(model);
+        }
+    }
+
+    module ModelAndCollection {
+        function test_url() {
+            Employee.prototype.url = () => '/employees';
+            EmployeeCollection.prototype.url = () => '/employees';
+        }
+
+        function test_parse() {
+            var model = new Employee();
+            model.parse('{}', {});
+            var collection = new EmployeeCollection;
+            collection.parse('{}', {});
+        }
+
+        function test_toJSON() {
+            var model = new Employee();
+            model.toJSON({});
+            var collection = new EmployeeCollection;
+            collection.toJSON({});
+        }
+
+        function test_sync() {
+            var model = new Employee();
+            model.sync();
+            var collection = new EmployeeCollection;
+            collection.sync();
+        }
+    }
+
+    module Model {
+        function test_validationError() {
+            var model = new Employee;
+            if (model.validationError) {
+                console.log('has validation errors');
+            }
+        }
+
+        function test_fetch() {
+            var model = new Employee({ id: 1 });
+            model.fetch({
+                success: () => { },
+                error: () => { }
+            });
+        }
+
+        function test_set() {
+            var model = new Employee;
+            model.set({ name: 'JoeDoe', age: 21 }, { validate: false });
+            model.set('name', 'JoeDoes', { validate: false });
+        }
+
+        function test_destroy() {
+            var model = new Employee;
+            model.destroy({
+                wait: true,
+                success: (m?, response?, options?) => { },
+                error: (m?, jqxhr?, options?) => { }
+            });
+
+            model.destroy({
+                success: (m?, response?, options?) => { },
+                error: (m?, jqxhr?) => { }
+            });
+
+            model.destroy({
+                success: () => { },
+                error: (m?, jqxhr?) => { }
+            });
+        }
+
+        function test_save() {
+            var model = new Employee;
+
+            model.save({
+                    name: 'Joe Doe',
+                    age: 21
+                },
+                {
+                    wait: true,
+                    validate: false,
+                    success: (m?, response?, options?) => { },
+                    error: (m?, jqxhr?, options?) => { }
+                });
+
+            model.save({
+                    name: 'Joe Doe',
+                    age: 21
+                },
+                {
+                    success: () => { },
+                    error: (m?, jqxhr?) => { }
+                });
+        }
+
+        function test_validate() {
+            var model = new Employee;
+
+            model.validate({ name: 'JoeDoe', age: 21 }, { validateAge: false })
+        }
+    }
+
+    module Collection {
+        function test_fetch() {
+            var collection = new EmployeeCollection;
+            collection.fetch({ reset: true });
+        }
+
+        function test_create() {
+            var collection = new EmployeeCollection;
+            var model = new Employee;
+
+            collection.create(model, {
+                validate: false
+            });
+        }
+    }
+
+    module Router {
+        function test_navigate() {
+            var router = new Backbone.Router;
+
+            router.navigate('/employees', { trigger: true });
+            router.navigate('/employees', true);
+        }
+    }
+}

backbone/backbone.d.ts

@@ -3,374 +3,5 @@
 // Definitions by: Boris Yankov <https://github.com/borisyankov/>, Natan Vivo <https://github.com/nvivo/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-/// <reference path="../jquery/jquery.d.ts" />
 /// <reference path="../underscore/underscore.d.ts" />
-
-declare module Backbone {
-
-    interface AddOptions extends Silenceable {
-        at?: number;
-    }
-
-    interface HistoryOptions extends Silenceable {
-        pushState?: boolean;
-        root?: string;
-    }
-
-    interface NavigateOptions {
-        trigger?: boolean;
-        replace?: boolean;
-    }
-
-    interface RouterOptions {
-        routes: any;
-    }
-
-    interface Silenceable {
-        silent?: boolean;
-    }
-
-    interface Validable {
-        validate?: boolean;
-    }
-
-    interface Waitable {
-        wait?: boolean;
-    }
-
-    interface Parseable {
-        parse?: any;
-    }
-
-    interface PersistenceOptions {
-        url?: string;
-        beforeSend?: (jqxhr: JQueryXHR) => void;
-        success?: (modelOrCollection?: any, response?: any, options?: any) => void;
-        error?: (modelOrCollection?: any, jqxhr?: JQueryXHR, options?: any) => void;
-    }
-
-    interface ModelSetOptions extends Silenceable, Validable {
-    }
-
-    interface ModelFetchOptions extends PersistenceOptions, ModelSetOptions, Parseable {
-    }
-
-    interface ModelSaveOptions extends Silenceable, Waitable, Validable, Parseable, PersistenceOptions {
-        patch?: boolean;
-    }
-
-    interface ModelDestroyOptions extends Waitable, PersistenceOptions {
-    }
-
-    interface CollectionFetchOptions extends PersistenceOptions, Parseable {
-        reset?: boolean;
-    }
-
-    class Events {
-        on(eventName: string, callback?: Function, context?: any): any;
-        off(eventName?: string, callback?: Function, context?: any): any;
-        trigger(eventName: string, ...args: any[]): any;
-        bind(eventName: string, callback: Function, context?: any): any;
-        unbind(eventName?: string, callback?: Function, context?: any): any;
-
-        once(events: string, callback: Function, context?: any): any;
-        listenTo(object: any, events: string, callback: Function): any;
-        listenToOnce(object: any, events: string, callback: Function): any;
-        stopListening(object?: any, events?: string, callback?: Function): any;
-    }
-
-    class ModelBase extends Events {
-        url: any;
-        parse(response: any, options?: any): any;
-        toJSON(options?: any): any;
-        sync(...arg: any[]): JQueryXHR;
-    }
-
-    class Model extends ModelBase {
-
-        /**
-        * Do not use, prefer TypeScript's extend functionality.
-        **/
-        private static extend(properties: any, classProperties?: any): any;
-
-        attributes: any;
-        changed: any[];
-        cid: string;
-        collection: Collection<any>;
-
-        /**
-        * Default attributes for the model. It can be an object hash or a method returning an object hash.
-        * For assigning an object hash, do it like this: this.defaults = <any>{ attribute: value, ... };
-        * That works only if you set it in the constructor or the initialize method.
-        **/
-        defaults(): any;
-        id: any;
-        idAttribute: string;
-        validationError: any;
-        urlRoot: any;
-
-        constructor(attributes?: any, options?: any);
-        initialize(attributes?: any, options?: any): void;
-
-        fetch(options?: ModelFetchOptions): JQueryXHR;
-
-        /**
-        * For strongly-typed access to attributes, use the `get` method only privately in public getter properties.
-        * @example
-        * get name(): string {
-        *    return super.get("name");
-        * }
-        **/
-        /*private*/ get(attributeName: string): any;
-
-        /**
-        * For strongly-typed assignment of attributes, use the `set` method only privately in public setter properties.
-        * @example
-        * set name(value: string) {
-        *    super.set("name", value);
-        * }
-        **/
-        /*private*/ set(attributeName: string, value: any, options?: ModelSetOptions): Model;
-        set(obj: any, options?: ModelSetOptions): Model;
-
-        change(): any;
-        changedAttributes(attributes?: any): any[];
-        clear(options?: Silenceable): any;
-        clone(): Model;
-        destroy(options?: ModelDestroyOptions): any;
-        escape(attribute: string): string;
-        has(attribute: string): boolean;
-        hasChanged(attribute?: string): boolean;
-        isNew(): boolean;
-        isValid(options?:any): boolean;
-        previous(attribute: string): any;
-        previousAttributes(): any[];
-        save(attributes?: any, options?: ModelSaveOptions): any;
-        unset(attribute: string, options?: Silenceable): Model;
-        validate(attributes: any, options?: any): any;
-
-        private _validate(attributes: any, options: any): boolean;
-
-        // mixins from underscore
-
-        keys(): string[];
-        values(): any[];
-        pairs(): any[];
-        invert(): any;
-        pick(keys: string[]): any;
-        pick(...keys: string[]): any;
-        omit(keys: string[]): any;
-        omit(...keys: string[]): any;
-    }
-
-    class Collection<TModel extends Model> extends ModelBase {
-
-        /**
-        * Do not use, prefer TypeScript's extend functionality.
-        **/
-        private static extend(properties: any, classProperties?: any): any;
-
-        model: new (...args:any[]) => TModel;
-        models: TModel[];
-        length: number;
-
-        constructor(models?: TModel[] | Object[], options?: any);
-        initialize(models?: TModel[] | Object[], options?: any): void;
-
-        fetch(options?: CollectionFetchOptions): JQueryXHR;
-
-        comparator(element: TModel): number;
-        comparator(compare: TModel, to?: TModel): number;
-
-        add(model: {}|TModel, options?: AddOptions): TModel;
-        add(models: ({}|TModel)[], options?: AddOptions): TModel[];
-        at(index: number): TModel;
-        /**
-         * Get a model from a collection, specified by an id, a cid, or by passing in a model.
-         **/
-        get(id: number|string|Model): TModel;
-        create(attributes: any, options?: ModelSaveOptions): TModel;
-        pluck(attribute: string): any[];
-        push(model: TModel, options?: AddOptions): TModel;
-        pop(options?: Silenceable): TModel;
-        remove(model: TModel, options?: Silenceable): TModel;
-        remove(models: TModel[], options?: Silenceable): TModel[];
-        reset(models?: TModel[], options?: Silenceable): TModel[];
-        set(models?: TModel[], options?: Silenceable): TModel[];
-        shift(options?: Silenceable): TModel;
-        sort(options?: Silenceable): Collection<TModel>;
-        unshift(model: TModel, options?: AddOptions): TModel;
-        where(properties: any): TModel[];
-        findWhere(properties: any): TModel;
-
-        private _prepareModel(attributes?: any, options?: any): any;
-        private _removeReference(model: TModel): void;
-        private _onModelEvent(event: string, model: TModel, collection: Collection<TModel>, options: any): void;
-
-        // mixins from underscore
-
-        all(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
-        any(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
-        collect(iterator: (element: TModel, index: number, context?: any) => any[], context?: any): any[];
-        chain(): any;
-        contains(value: any): boolean;
-        countBy(iterator: (element: TModel, index: number) => any): _.Dictionary<number>;
-        countBy(attribute: string): _.Dictionary<number>;
-        detect(iterator: (item: any) => boolean, context?: any): any; // ???
-        drop(): TModel;
-        drop(n: number): TModel[];
-        each(iterator: (element: TModel, index: number, list?: any) => void, context?: any): any;
-        every(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
-        filter(iterator: (element: TModel, index: number) => boolean, context?: any): TModel[];
-        find(iterator: (element: TModel, index: number) => boolean, context?: any): TModel;
-        first(): TModel;
-        first(n: number): TModel[];
-        foldl(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
-        forEach(iterator: (element: TModel, index: number, list?: any) => void, context?: any): any;
-        groupBy(iterator: (element: TModel, index: number) => string, context?: any): _.Dictionary<TModel[]>;
-        groupBy(attribute: string, context?: any): _.Dictionary<TModel[]>;
-        include(value: any): boolean;
-        indexOf(element: TModel, isSorted?: boolean): number;
-        initial(): TModel;
-        initial(n: number): TModel[];
-        inject(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
-        isEmpty(object: any): boolean;
-        invoke(methodName: string, args?: any[]): any;
-        last(): TModel;
-        last(n: number): TModel[];
-        lastIndexOf(element: TModel, fromIndex?: number): number;
-        map(iterator: (element: TModel, index: number, context?: any) => any, context?: any): any[];
-        max(iterator?: (element: TModel, index: number) => any, context?: any): TModel;
-        min(iterator?: (element: TModel, index: number) => any, context?: any): TModel;
-        reduce(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any;
-        select(iterator: any, context?: any): any[];
-        size(): number;
-        shuffle(): any[];
-        slice(min: number, max?: number): TModel[];
-        some(iterator: (element: TModel, index: number) => boolean, context?: any): boolean;
-        sortBy(iterator: (element: TModel, index: number) => number, context?: any): TModel[];
-        sortBy(attribute: string, context?: any): TModel[];
-        sortedIndex(element: TModel, iterator?: (element: TModel, index: number) => number): number;
-        reduceRight(iterator: (memo: any, element: TModel, index: number) => any, initialMemo: any, context?: any): any[];
-        reject(iterator: (element: TModel, index: number) => boolean, context?: any): TModel[];
-        rest(): TModel;
-        rest(n: number): TModel[];
-        tail(): TModel;
-        tail(n: number): TModel[];
-        toArray(): any[];
-        without(...values: any[]): TModel[];
-    }
-
-    class Router extends Events {
-
-        /**
-        * Do not use, prefer TypeScript's extend functionality.
-        **/
-        private static extend(properties: any, classProperties?: any): any;
-
-        /**
-        * Routes hash or a method returning the routes hash that maps URLs with parameters to methods on your Router.
-        * For assigning routes as object hash, do it like this: this.routes = <any>{ "route": callback, ... };
-        * That works only if you set it in the constructor or the initialize method.
-        **/
-        routes: any;
-
-        constructor(options?: RouterOptions);
-        initialize(options?: RouterOptions): void;
-        route(route: string|RegExp, name: string, callback?: Function): Router;
-        navigate(fragment: string, options?: NavigateOptions): Router;
-        navigate(fragment: string, trigger?: boolean): Router;
-
-        private _bindRoutes(): void;
-        private _routeToRegExp(route: string): RegExp;
-        private _extractParameters(route: RegExp, fragment: string): string[];
-    }
-
-    var history: History;
-
-    class History extends Events {
-
-        handlers: any[];
-        interval: number;
-
-        start(options?: HistoryOptions): boolean;
-
-        getHash(window?: Window): string;
-        getFragment(fragment?: string, forcePushState?: boolean): string;
-        stop(): void;
-        route(route: string, callback: Function): number;
-        checkUrl(e?: any): void;
-        loadUrl(fragmentOverride: string): boolean;
-        navigate(fragment: string, options?: any): boolean;
-        started: boolean;
-        options: any;
-
-        private _updateHash(location: Location, fragment: string, replace: boolean): void;
-    }
-
-   interface ViewOptions<TModel extends Model> {
-      model?: TModel;
-       // TODO: quickfix, this can't be fixed easy. The collection does not need to have the same model as the parent view.
-      collection?: Backbone.Collection<any>;
-      el?: any;
-      id?: string;
-      className?: string;
-      tagName?: string;
-      attributes?: {[id: string]: any};
-    }
-
-    class View<TModel extends Model> extends Events {
-
-        /**
-        * Do not use, prefer TypeScript's extend functionality.
-        **/
-        private static extend(properties: any, classProperties?: any): any;
-
-        constructor(options?: ViewOptions<TModel>);
-        initialize(options?: ViewOptions<TModel>): void;
-
-        /**
-        * Events hash or a method returning the events hash that maps events/selectors to methods on your View.
-        * For assigning events as object hash, do it like this: this.events = <any>{ "event:selector": callback, ... };
-        * That works only if you set it in the constructor or the initialize method.
-        **/
-        events(): any;
-
-        $(selector: string): JQuery;
-        model: TModel;
-        collection: Collection<TModel>;
-        //template: (json, options?) => string;
-        setElement(element: HTMLElement|JQuery, delegate?: boolean): View<TModel>;
-        id: string;
-        cid: string;
-        className: string;
-        tagName: string;
-
-        el: any;
-        $el: JQuery;
-        setElement(element: any): View<TModel>;
-        attributes: any;
-        $(selector: any): JQuery;
-        render(): View<TModel>;
-        remove(): View<TModel>;
-        make(tagName: any, attributes?: any, content?: any): any;
-        delegateEvents(events?: any): any;
-        undelegateEvents(): any;
-
-        _ensureElement(): void;
-    }
-
-    // SYNC
-    function sync(method: string, model: Model, options?: JQueryAjaxSettings): any;
-    function ajax(options?: JQueryAjaxSettings): JQueryXHR;
-    var emulateHTTP: boolean;
-    var emulateJSON: boolean;
-
-    // Utility
-    function noConflict(): typeof Backbone;
-    var $: JQueryStatic;
-}
-
-declare module "backbone" {
-    export = Backbone;
-}
+/// <reference path="./backbone-global.d.ts" />

barcode/barcode-tests.ts

@@ -0,0 +1,22 @@
+/// <reference path="barcode.d.ts" />
+import barcode = require('barcode');
+import path = require('path');
+
+var code39 = barcode('code39', {
+    data: "it works",
+    width: 400,
+    height: 100,
+});
+
+code39.getStream(function (err, readStream) {
+    if (err) throw err;
+
+    // 'readStream' is an instance of ReadableStream
+});
+
+var outfile = path.join(__dirname, 'imgs', 'mycode.png');
+code39.saveImage(outfile, function (err) {
+    if (err) throw err;
+
+    console.log('File has been written!');
+});

barcode/barcode.d.ts

@@ -0,0 +1,25 @@
+// Type definitions for barcode
+// Project: https://github.com/samt/barcode
+// Definitions by: Pascal Vomhoff <https://github.com/pvomhoff>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+
+declare module "barcode" {
+
+    interface BarcodeOptions {
+        data:string|number;
+        width:number;
+        height:number;
+    }
+
+    interface BarcodeResult {
+        getStream(callback:(err:NodeJS.ErrnoException, stream:NodeJS.ReadableStream) => void):void;
+        saveImage(outputfilePath:string, callback:(err:NodeJS.ErrnoException) => void):void;
+        getBase64(callback:(err:NodeJS.ErrnoException, base64String:string) => void):void;
+    }
+
+    function barcode(type:string, options:BarcodeOptions):BarcodeResult;
+
+    export = barcode;
+}

benchmark/benchmark-tests.ts

@@ -0,0 +1,237 @@
+/// <reference path="./benchmark.d.ts"/>
+import Benchmark = require("benchmark");
+
+var suite = new Benchmark.Suite;
+
+// add tests
+suite.add('RegExp#test', function() {
+  /o/.test('Hello World!');
+})
+.add('String#indexOf', function() {
+  'Hello World!'.indexOf('o') > -1;
+})
+.add('String#match', function() {
+  !!'Hello World!'.match(/o/);
+})
+// add listeners
+.on('cycle', function(event: {target: any}) {
+  console.log(String(event.target));
+})
+.on('complete', function() {
+  console.log('Fastest is ' + this.filter('fastest').pluck('name'));
+})
+// run async
+.run({ 'async': true });
+
+var fn: Function;
+var onStart: Function;
+var onCycle: Function;
+var onAbort: Function;
+var onError: Function;
+var onReset: Function;
+var onComplete: Function;
+var setup: Function;
+var teardown: Function;
+var benches: Benchmark[];
+var listener: Function;
+var count: number;
+
+// basic usage (the `new` operator is optional)
+var bench = new Benchmark(fn);
+
+// or using a name first
+var bench = new Benchmark('foo', fn);
+
+// or with options
+var bench = new Benchmark('foo', fn, {
+
+  // displayed by Benchmark#toString if `name` is not available
+  'id': 'xyz',
+
+  // called when the benchmark starts running
+  'onStart': onStart,
+
+  // called after each run cycle
+  'onCycle': onCycle,
+
+  // called when aborted
+  'onAbort': onAbort,
+
+  // called when a test errors
+  'onError': onError,
+
+  // called when reset
+  'onReset': onReset,
+
+  // called when the benchmark completes running
+  'onComplete': onComplete,
+
+  // compiled/called before the test loop
+  'setup': setup,
+
+  // compiled/called after the test loop
+  'teardown': teardown
+});
+
+// or name and options
+var bench = new Benchmark('foo', {
+
+  // a flag to indicate the benchmark is deferred
+  'defer': true,
+
+  // benchmark test function
+  'fn': function(deferred: {resolve(): void}) {
+    // call resolve() when the deferred test is finished
+    deferred.resolve();
+  }
+});
+
+// or options only
+var bench = new Benchmark({
+
+  // benchmark name
+  'name': 'foo',
+
+  // benchmark test as a string
+  'fn': '[1,2,3,4].sort()'
+});
+
+// a test’s `this` binding is set to the benchmark instance
+var bench = new Benchmark('foo', function() {
+  'My name is '.concat(this.name); // My name is foo
+});
+
+// get odd numbers
+Benchmark.filter([1, 2, 3, 4, 5], function(n) {
+  return n % 2;
+}); // -> [1, 3, 5];
+
+// get fastest benchmarks
+Benchmark.filter(benches, 'fastest');
+
+// get slowest benchmarks
+Benchmark.filter(benches, 'slowest');
+
+// get benchmarks that completed without erroring
+Benchmark.filter(benches, 'successful');
+
+// invoke `reset` on all benchmarks
+Benchmark.invoke(benches, 'reset');
+
+// invoke `emit` with arguments
+Benchmark.invoke(benches, 'emit', 'complete', listener);
+
+// invoke `run(true)`, treat benchmarks as a queue, and register invoke callbacks
+Benchmark.invoke(benches, {
+
+  // invoke the `run` method
+  'name': 'run',
+
+  // pass a single argument
+  'args': true,
+
+  // treat as queue, removing benchmarks from front of `benches` until empty
+  'queued': true,
+
+  // called before any benchmarks have been invoked.
+  'onStart': onStart,
+
+  // called between invoking benchmarks
+  'onCycle': onCycle,
+
+  // called after all benchmarks have been invoked.
+  'onComplete': onComplete
+});
+
+var element: HTMLElement;
+// basic usage
+var bench = new Benchmark({
+  'setup': function() {
+    var c = this.count,
+      element = document.getElementById('container');
+    while (c--) {
+      element.appendChild(document.createElement('div'));
+    }
+  },
+  'fn': function() {
+    element.removeChild(element.lastChild);
+  }
+});
+
+// or using strings
+var bench = new Benchmark({
+  'setup': '\
+    var a = 0;\n\
+    (function() {\n\
+      (function() {\n\
+        (function() {',
+  'fn': 'a += 1;',
+  'teardown': '\
+         }())\n\
+       }())\n\
+     }())'
+});
+
+var bizarro = bench.clone({
+  'name': 'doppelganger'
+});
+
+// unregister a listener for an event type
+bench.off('cycle', listener);
+
+// unregister a listener for multiple event types
+bench.off('start cycle', listener);
+
+// unregister all listeners for an event type
+bench.off('cycle');
+
+// unregister all listeners for multiple event types
+bench.off('start cycle complete');
+
+// unregister all listeners for all event types
+bench.off();
+
+// register a listener for an event type
+bench.on('cycle', listener);
+
+// register a listener for multiple event types
+bench.on('start cycle', listener);
+
+// basic usage
+bench.run();
+
+// or with options
+bench.run({ 'async': true });
+
+// basic usage
+suite.add(fn);
+
+// or using a name first
+suite.add('foo', fn);
+
+// or with options
+suite.add('foo', fn, {
+  'onCycle': onCycle,
+  'onComplete': onComplete
+});
+
+// or name and options
+suite.add('foo', {
+  'fn': fn,
+  'onCycle': onCycle,
+  'onComplete': onComplete
+});
+
+// or options only
+suite.add({
+  'name': 'foo',
+  'fn': fn,
+  'onCycle': onCycle,
+  'onComplete': onComplete
+});
+
+// basic usage
+suite.run();
+
+// or with options
+suite.run({ 'async': true, 'queued': true });

benchmark/benchmark.d.ts

@@ -0,0 +1,192 @@
+// Type definitions for Benchmark v1.0.0
+// Project: http://benchmarkjs.com
+// Definitions by: Asana <https://asana.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module "benchmark" {
+    class Benchmark {
+        static deepClone<T>(value: T): T;
+        static each(obj: Object | any[], callback: Function, thisArg?: any): void;
+        static extend(destination: Object, ...sources: Object[]): Object;
+        static filter<T>(arr: T[], callback: (value: T) => any, thisArg?: any): T[];
+        static filter<T>(arr: T[], filter: string, thisArg?: any): T[];
+        static forEach<T>(arr: T[], callback: (value: T) => any, thisArg?: any): void;
+        static formatNumber(num: number): string;
+        static forOwn(obj: Object, callback: Function, thisArg?: any): void;
+        static hasKey(obj: Object, key: string): boolean;
+        static indexOf<T>(arr: T[], value: T, fromIndex?: number): number;
+        static interpolate(template: string, values: Object): string;
+        static invoke(benches: Benchmark[], name: string | Object, ...args: any[]): any[];
+        static join(obj: Object, separator1?: string, separator2?: string): string;
+        static map<T, K>(arr: T[], callback: (value: T) => K, thisArg?: any): K[];
+        static pluck<T, K>(arr: T[], key: string): K[];
+        static reduce<T, K>(arr: T[], callback: (accumulator: K, value: T) => K, thisArg?: any): K;
+
+        static options: Benchmark.Options;
+        static platform: Benchmark.Platform;
+        static support: Benchmark.Support;
+        static version: string;
+
+        constructor(fn: Function | string, options?: Benchmark.Options);
+        constructor(name: string, fn: Function | string, options?: Benchmark.Options);
+        constructor(name: string, options?: Benchmark.Options);
+        constructor(options: Benchmark.Options);
+
+        aborted: boolean;
+        compiled: Function | string;
+        count: number;
+        cycles: number;
+        error: Error;
+        fn: Function | string;
+        hz: number;
+        running: boolean;
+        setup: Function | string;
+        teardown: Function | string;
+
+        stats: Benchmark.Stats;
+        times: Benchmark.Times;
+
+        abort(): Benchmark;
+        clone(options: Benchmark.Options): Benchmark;
+        compare(benchmark: Benchmark): number;
+        emit(type: string | Object): any;
+        listeners(type: string): Function[];
+        off(type?: string, listener?: Function): Benchmark;
+        off(types: string[]): Benchmark;
+        on(type?: string, listener?: Function): Benchmark;
+        on(types: string[]): Benchmark;
+        reset(): Benchmark;
+        run(options?: Benchmark.Options): Benchmark;
+        toString(): string;
+    }
+
+    module Benchmark {
+        export interface Options {
+            async?: boolean;
+            defer?: boolean;
+            delay?: number;
+            id?: string;
+            initCount?: number;
+            maxTime?: number;
+            minSamples?: number;
+            minTime?: number;
+            name?: string;
+            onAbort?: Function;
+            onComplete?: Function;
+            onCycle?: Function;
+            onError?: Function;
+            onReset?: Function;
+            onStart?: Function;
+            setup?: Function | string;
+            teardown?: Function | string;
+            fn?: Function | string;
+            queued?: boolean;
+        }
+
+        export interface Platform {
+            description: string;
+            layout: string;
+            manufacturer: string;
+            name: string;
+            os: string;
+            prerelease: string;
+            product: string;
+            version: string;
+            toString(): string;
+        }
+
+        export interface Support {
+            air: boolean;
+            argumentsClass: boolean;
+            browser: boolean;
+            charByIndex: boolean;
+            charByOwnIndex: boolean;
+            decompilation: boolean;
+            descriptors: boolean;
+            getAllKeys: boolean;
+            iteratesOwnFirst: boolean;
+            java: boolean;
+            nodeClass: boolean;
+            timeout: boolean;
+        }
+
+        export interface Stats {
+            deviation: number;
+            mean: number;
+            moe: number;
+            rme: number;
+            sample: any[];
+            sem: number;
+            variance: number;
+        }
+
+        export interface Times {
+            cycle: number;
+            elapsed: number;
+            period: number;
+            timeStamp: number;
+        }
+
+        export class Deferred {
+            constructor(clone: Benchmark);
+
+            benchmark: Benchmark;
+            cycles: number;
+            elapsed: number;
+            timeStamp: number;
+        }
+
+        export class Event {
+            constructor(type: string | Object);
+
+            aborted: boolean;
+            cancelled: boolean;
+            currentTarget: Object;
+            result: any;
+            target: Object;
+            timeStamp: number;
+            type: string;
+        }
+
+        export class Suite {
+            static options: { name: string };
+
+            constructor(name?: string, options?: Options);
+
+            aborted: boolean;
+            length: number;
+            running: boolean;
+            abort(): Suite;
+            add(name: string, fn: Function | string, options?: Options): Suite;
+            add(fn: Function | string, options?: Options): Suite;
+            add(name: string, options?: Options): Suite;
+            add(options: Options): Suite;
+            clone(options: Options): Suite;
+            emit(type: string | Object): any;
+            filter(callback: Function | string): Suite;
+            forEach(callback: Function): Suite;
+            indexOf(value: any): number;
+            invoke(name: string, ...args: any[]): any[];
+            join(separator?: string): string;
+            listeners(type: string): Function[];
+            map(callback: Function): any[];
+            off(type?: string, callback?: Function): Benchmark;
+            off(types: string[]): Benchmark;
+            on(type?: string, callback?: Function): Benchmark;
+            on(types: string[]): Benchmark;
+            pluck(property: string): any[];
+            pop(): Function;
+            push(benchmark: Benchmark): number;
+            reduce<T>(callback: Function, accumulator: T): T;
+            reset(): Suite;
+            reverse(): any[];
+            run(options?: Options): Suite;
+            shift(): Benchmark;
+            slice(start: number, end: number): any[];
+            slice(start: number, deleteCount: number, ...values: any[]): any[];
+            unshift(benchmark: Benchmark): number;
+        }
+    }
+
+    export = Benchmark;
+}

better-curry/better-curry-tests.ts

@@ -1,27 +1,27 @@
-/// <reference path="better-curry.d.ts" />
-
-import bc = require('better-curry');
-bc.flatten([1,2,3,[1,2],['a']]) === [];
-bc.MAX_OPTIMIZED = 5;
-
-function fn(...args: number[]): number[] {
-    return [].concat([1]);
-}
-
-function fn2(arg1: string, arg2: any): number {
-    return parseInt(arg1 + String(arg2)) + 1;
-}
-
-bc.predefine(fn, [1,2])() === [];
-bc.predefine(fn, [1,2]).__length === 3;
-
-var f = bc.wrap(fn2, {}, 10, true);
-f('1', 2) === 3;
-
-var delegate = bc.delegate({}, 'ok');
-delegate.access('ok') === delegate;
-delegate.getter('getter').setter('setter') === delegate;
-delegate.all(['1','2']);
-delegate.revoke('adsf').access('asdf');
-
+/// <reference path="better-curry.d.ts" />
+
+import bc = require('better-curry');
+bc.flatten([1,2,3,[1,2],['a']]) === [];
+bc.MAX_OPTIMIZED = 5;
+
+function fn(...args: number[]): number[] {
+    return [].concat([1]);
+}
+
+function fn2(arg1: string, arg2: any): number {
+    return parseInt(arg1 + String(arg2)) + 1;
+}
+
+bc.predefine(fn, [1,2])() === [];
+bc.predefine(fn, [1,2]).__length === 3;
+
+var f = bc.wrap(fn2, {}, 10, true);
+f('1', 2) === 3;
+
+var delegate = bc.delegate({}, 'ok');
+delegate.access('ok') === delegate;
+delegate.getter('getter').setter('setter') === delegate;
+delegate.all(['1','2']);
+delegate.revoke('adsf').access('asdf');
+
 BetterCurry.wrap(fn2, {}, -1, false).__length === 10;

better-curry/better-curry.d.ts

@@ -1,50 +1,50 @@
-// Type definitions for better-curry
-// Project: https://github.com/pocesar/js-bettercurry
-// Definitions by: Paulo Cesar <https://github.com/pocesar>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare var BetterCurry: BetterCurryModule.BetterCurry;
-
-declare module BetterCurryModule {
-
-    export interface DelegateOptions {
-        as?: string;
-        len?: number;
-        args?: any[];
-        name?: string;
-    }
-
-    export class Delegate<T> {
-        proto: T;
-        target: string;
-        methods: any[];
-        getters: any[];
-        setters: any[];
-        all: (skip?: string[]) => void;
-        method: (name: string|DelegateOptions) => Delegate<T>;
-        getter: (name: string|DelegateOptions) => Delegate<T>;
-        setter: (name: string|DelegateOptions) => Delegate<T>;
-        access: (name: string|DelegateOptions) => Delegate<T>;
-        revoke: (name: string) => Delegate<T>;
-        constructor(proto: T, target: string);
-    }
-
-    export interface OriginalFunctionReminder<T> extends Function {
-        __length: number;
-    }
-
-    export interface BetterCurry {
-        predefine: <T extends Function>(fn: T, args: any[], context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
-        wrap: <T extends Function>(fn: T, context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
-        flatten: (...args: Array<Array<any>|any>) => any[];
-        delegate: <T>(proto: T, target: string) => Delegate<T>;
-        MAX_OPTIMIZED: number;
-    }
-
-}
-
-declare module 'better-curry' {
-    var bc: BetterCurryModule.BetterCurry;
-
-    export = bc;
+// Type definitions for better-curry
+// Project: https://github.com/pocesar/js-bettercurry
+// Definitions by: Paulo Cesar <https://github.com/pocesar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var BetterCurry: BetterCurryModule.BetterCurry;
+
+declare module BetterCurryModule {
+
+    export interface DelegateOptions {
+        as?: string;
+        len?: number;
+        args?: any[];
+        name?: string;
+    }
+
+    export class Delegate<T> {
+        proto: T;
+        target: string;
+        methods: any[];
+        getters: any[];
+        setters: any[];
+        all: (skip?: string[]) => void;
+        method: (name: string|DelegateOptions) => Delegate<T>;
+        getter: (name: string|DelegateOptions) => Delegate<T>;
+        setter: (name: string|DelegateOptions) => Delegate<T>;
+        access: (name: string|DelegateOptions) => Delegate<T>;
+        revoke: (name: string) => Delegate<T>;
+        constructor(proto: T, target: string);
+    }
+
+    export interface OriginalFunctionReminder<T> extends Function {
+        __length: number;
+    }
+
+    export interface BetterCurry {
+        predefine: <T extends Function>(fn: T, args: any[], context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
+        wrap: <T extends Function>(fn: T, context?: Object, len?: number, checkArguments?: boolean) => OriginalFunctionReminder<T>;
+        flatten: (...args: Array<Array<any>|any>) => any[];
+        delegate: <T>(proto: T, target: string) => Delegate<T>;
+        MAX_OPTIMIZED: number;
+    }
+
+}
+
+declare module 'better-curry' {
+    var bc: BetterCurryModule.BetterCurry;
+
+    export = bc;
 }

big-integer/big-integer-tests.ts

@@ -4,6 +4,9 @@
 var noArgument = bigInt(),
     numberArgument = bigInt( 93 ),
     stringArgument = bigInt( "75643564363473453456342378564387956906736546456235345" ),
+    baseArgumentInt = bigInt( "101010", 2 ),
+    baseArgumentStr = bigInt( "101010", "2" ),
+    baseArgumentBi  = bigInt( "101010", bigInt( 2 ) ), 
     bigIntArgument = bigInt( noArgument );
 
 // method tests
@@ -111,4 +114,4 @@ isNumber = x.toJSNumber();
 
 isString = x.toString();
 
-isNumber = x.valueOf();
+isNumber = x.valueOf();

big-integer/big-integer.d.ts

@@ -214,7 +214,7 @@ interface BigIntegerStatic {
     /** Parse a Javascript number into a bigInt */
     ( number: number ): BigInteger;
     /** Parse a string into a bigInt */
-    ( string: string ): BigInteger;
+    ( string: string,  base?: string | number | BigInteger): BigInteger;
     /** no-op */
     ( bigInt: BigInteger ): BigInteger;
 }
@@ -223,4 +223,4 @@ declare var bigInt: BigIntegerStatic;
 
 declare module "big-integer" {
     export = bigInt;
-}
+}

bingmaps/bingmaps-tests.ts

@@ -1,4 +1,4 @@
-/// <reference path="Microsoft.Maps.d.ts"/> 
+/// <reference path="Microsoft.Maps.d.ts"/>
 /// <reference path="Microsoft.Maps.AdvancedShapes.d.ts"/>
 /// <reference path="Microsoft.Maps.Directions.d.ts"/>
 /// <reference path="Microsoft.Maps.Search.d.ts"/>
@@ -55,7 +55,7 @@ module BingMapsTests {
                         locations.push(location);
                     }
 
-                    // Sets the view of the map to the smallest size that contains all of the 
+                    // Sets the view of the map to the smallest size that contains all of the
                     // specified locations (in this case the pusphin locations)
                     map.setView({ bounds: Microsoft.Maps.LocationRect.fromLocations(locations) });
                 }

bluebird/bluebird-tests.ts

@@ -36,6 +36,9 @@ interface Foo {
 interface Bar {
 	bar(): string;
 }
+interface Baz {
+  baz(): string;
+}
 
 // - - - - - - - - - - - - - - - - -
 
@@ -61,6 +64,7 @@ interface StrBarArrMap {
 
 var foo: Foo;
 var bar: Bar;
+var baz: Baz;
 
 var fooArr: Foo[];
 var barArr: Bar[];
@@ -76,6 +80,7 @@ var voidProm: Promise<void>;
 
 var fooProm: Promise<Foo>;
 var barProm: Promise<Bar>;
+var bazProm: Promise<Baz>;
 
 // - - - - - - - - - - - - - - - - -
 
@@ -499,6 +504,30 @@ barProm = fooProm.race<Bar>();
 
 // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 
+Promise.all([fooProm, barProm]).then(result => {
+  result[0].foo();
+  result[1].bar();
+});
+
+Promise.all([fooProm, fooProm]).then(result => {
+  result[0].foo();
+  result[1].foo();
+});
+
+Promise.all([fooProm, barProm, bazProm]).then(result => {
+  result[0].foo();
+  result[1].bar();
+  result[2].baz();
+});
+
+Promise.all([fooProm, barProm, fooProm]).then(result => {
+  result[0].foo();
+  result[1].bar();
+  result[2].foo();
+});
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
 //TODO fix collection inference
 
 barArrProm = fooProm.map<Foo, Bar>((item: Foo, index: number, arrayLength: number) => {

bluebird/bluebird.d.ts

@@ -464,6 +464,11 @@ declare class Promise<R> implements Promise.Thenable<R>, Promise.Inspection<R> {
 	static all<R>(values: Promise.Thenable<R[]>): Promise<R[]>;
 	// array with promises of value
 	static all<R>(values: Promise.Thenable<R>[]): Promise<R[]>;
+    // array with promises of different types
+	static all<T1, T2>(values: [Promise.Thenable<T1>, Promise.Thenable<T2>]): Promise<[T1, T2]>;
+	static all<T1, T2, T3>(values: [Promise.Thenable<T1>, Promise.Thenable<T2>, Promise.Thenable<T3>]): Promise<[T1, T2, T3]>;
+	static all<T1, T2, T3, T4>(values: [Promise.Thenable<T1>, Promise.Thenable<T2>, Promise.Thenable<T3>, Promise.Thenable<T4>]): Promise<[T1, T2, T3, T4]>;
+	static all<T1, T2, T3, T4, T5>(values: [Promise.Thenable<T1>, Promise.Thenable<T2>, Promise.Thenable<T3>, Promise.Thenable<T4>, Promise.Thenable<T5>]): Promise<[T1, T2, T3, T4, T5]>;
 	// array with values
 	static all<R>(values: R[]): Promise<R[]>;
 

bootstrap-maxlength/bootstrap-maxlength-tests.ts

@@ -0,0 +1,70 @@
+/// <reference path="bootstrap-maxlength.d.ts"/>
+/// <reference path="../jquery/jquery.d.ts"/>
+
+// Examples from the projects github page
+$('input[maxlength]').maxlength();
+
+$('input.className').maxlength({
+    threshold: 20
+});
+
+$('input.className').maxlength({
+    alwaysShow: true,
+    threshold: 10,
+    warningClass: "label label-info",
+    limitReachedClass: "label label-warning",
+    placement: 'top',
+    preText: 'used ',
+    separator: ' of ',
+    postText: ' chars.'
+});
+
+$('input.className').maxlength({
+    alwaysShow: true,
+    threshold: 10,
+    warningClass: "label label-info",
+    limitReachedClass: "label label-warning",
+    placement: 'top',
+    message: 'used %charsTyped% of %charsTotal% chars.'
+});
+// Testing the events
+$('input.className').on('maxlength.shown', function(){
+    console.log('shown');
+});
+$('input.className').on('maxlength.hidden', function(){
+    console.log('hidden');
+});
+$('textarea').on('autosize.resized', function () {
+    $(this).trigger('maxlength.reposition');
+});
+
+
+// using message string
+$('input.className').maxlength({
+    message: 'used %charsTyped% of %charsTotal% chars.'
+});
+// using message function
+$('input.className').maxlength({
+    threshold: 20,
+    message: function (currentText, maxLength) {
+        return '' + Math.ceil(currentText.length / 160) + ' SMS Message(s)';
+    }
+});
+
+
+// placement string
+$('input.className').maxlength({
+    placement: 'top-left'
+});
+// placement object
+$('input.className').maxlength({
+    placement: {
+        top: 10,
+        left: '30%'
+    }
+});
+// placement function
+$('input.className').maxlength({
+    placement: function (currentInput: JQuery, maxLengthIndicator: JQuery, currentInputPosition: BootstrapMaxlength.PositionParam) {
+    }
+});

bootstrap-maxlength/bootstrap-maxlength.d.ts

@@ -0,0 +1,158 @@
+// Type definitions for bootstrap-maxlength v1.7.0
+// Project: https://github.com/mimo84/bootstrap-maxlength
+// Definitions by: Dan Manastireanu <https://github.com/danmana>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts" />
+
+declare module BootstrapMaxlength {
+
+    /**
+     * Possible options for the position of the counter. (passed to $.fn.css)
+     */
+    interface PlacementOptions {
+        /**
+         * The top position of the counter (Number of pixels, or a px or percent string)
+         */
+        top?: Number | string,
+        /**
+         * The right position of the counter (Number of pixels, or a px or percent string)
+         */
+        right?: Number | string,
+        /**
+         * The bottom position of the counter (Number of pixels, or a px or percent string)
+         */
+        bottom?: Number | string,
+        /**
+         * The left position of the counter (Number of pixels, or a px or percent string)
+         */
+        left?: Number | string,
+        /**
+         * The positioning to use. For example 'relative', 'absolute'
+         */
+        position?: string
+    }
+
+    /**
+     * Representation of the current input position
+     */
+    interface PositionParam {
+        top: Number,
+        right: Number,
+        bottom: Number,
+        left: Number,
+        width: Number,
+        height: Number
+    }
+
+    export interface Options {
+        /**
+         * If true the threshold will be ignored and the remaining length indication will be always showing up while typing or on focus on the input
+         * @default false
+         */
+        alwaysShow?: Boolean,
+        /**
+         * This is a number indicating how many chars are left to start displaying the indications
+         * @default 10
+         */
+        threshold?: Number,
+        /**
+         * It's the class of the element with the indicator. By default is the bootstrap "label label-success" but can be changed to anything you'd like.
+         * @default 'label label-success'
+         */
+        warningClass?: string,
+        /**
+         * It's the class the element gets when the limit is reached. Default is "label label-important label-danger" (to support Bootstrap 2 and 3).
+         * @default 'label label-important label-danger'
+         */
+        limitReachedClass?: string,
+        /**
+         * Represents the separator between the number of typed chars and total number of available chars.
+         * @default ' / '
+         */
+        separator?: string,
+        /**
+         * Is a string of text that can be outputted in front of the indicator.
+         * @default ''
+         */
+        preText?: string,
+        /**
+         * Is a string outputted after the indicator.
+         * @default ''
+         */
+        postText?: string,
+        /**
+         * If false, will display just the number of typed characters, e.g. will not display the max length.
+         * @default true
+         */
+        showMaxLength?: Boolean,
+        /**
+         * If false, will display just the remaining length, e.g. will display remaining lenght instead of number of typed characters.
+         * @default true
+         */
+        showCharsTyped?: Boolean,
+        /**
+         * Is a string, define where to output the counter.
+         * Options:  bottom, left, top, right, bottom-right, top-right, top-left, bottom-left and centered-right
+         * @default 'bottom'
+         */
+        placement?: string | PlacementOptions | ((currentInput: JQuery, maxLengthIndicator: JQuery, currentInputPosition: PositionParam) => void),
+        /**
+         * Appends the maxlength indicator badge to the parent of the input rather than to the body.
+         * @default false
+         */
+        appendToParent?: boolean,
+        /**
+         * An alternative way to provide the message text.
+         * String example: 'You have typed %charsTyped% chars, %charsRemaining% of %charsTotal% remaining'.
+         * %charsTyped%, %charsRemaining% and %charsTotal% will be replaced by the actual values. This overrides the options separator, preText, postText and showMaxLength.
+         * Alternatively you may supply a function that the current text and max length and returns the string to be displayed.
+         * Function example: function(currentText, maxLength) { return '' + Math.ceil(currentText.length / 160) + ' SMS Message(s)'; }
+         * @default null
+         */
+        message?: string | ((currentText : string, maxLength: Number) => string),
+        /**
+         * If true the input will count using utf8 bytesize/encoding. For example: the '£' character is counted as two characters.
+         * @default false
+         */
+        utf8?: boolean,
+        /**
+         * Shows the badge as soon as it is added to the page, similar to alwaysShow
+         * @default false
+         */
+        showOnReady?: boolean,
+        /**
+         * Count linebreak as 2 characters to match IE/Chrome textarea validation. As well as DB storage.
+         * @default true
+         */
+        twoCharLinebreak?: boolean,
+        /**
+         * Allows a custom attribute to display indicator without triggering native maxlength behaviour.
+         * Ignored if value greater than a native maxlength attribute.
+         * 'overmax' class gets added when exceeded to allow user to implement form validation.
+         * @default null (use the maxlength attribute and browser functionality)
+         */
+        customMaxAttribute?: string,
+        /**
+         * Will allow the input to be over the customMaxLength. Useful in soft max situations.
+         * @default false
+         */
+        allowOverMax?: boolean,
+        /**
+         * If the browser doesn't support the maxlength attribute, attempt to type more than
+         * the indicated chars, will be prevented.
+         * @default false
+         */
+        validate?: boolean
+    }
+}
+
+
+interface JQuery {
+    /** Apply the maxlength plugin on the selected elemens */
+    maxlength(options?: BootstrapMaxlength.Options): JQuery;
+    on(events: 'maxlength.shown', handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery;
+    on(events: 'maxlength.hidden', handler: (eventObject: JQueryEventObject, ...args: any[]) => any): JQuery;
+    trigger(eventType: 'maxlength.reposition', extraParameters?: any[]|Object): JQuery;
+
+}

bootstrap-notify/bootstrap-notify-tests.ts

@@ -1,9 +1,9 @@
 /// <reference path="bootstrap-notify.d.ts" />
 /// <reference path="../jquery/jquery.d.ts" />
-    
+
 //Test for bootstrap-notify v3.1.3
 //Copied example directly from Bootstrap-notify site
-	
+
 $.notify({
 	// options
 	icon: 'glyphicon glyphicon-warning-sign',
@@ -48,5 +48,5 @@ $.notify({
 			'<div class="progress-bar progress-bar-{0}" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100" style="width: 0%;"></div>' +
 		'</div>' +
 		'<a href="{3}" target="{4}" data-notify="url"></a>' +
-	'</div>' 
+	'</div>'
 });

bootstrap-notify/bootstrap-notify.d.ts.tscparams

@@ -1 +0,0 @@
-

bootstrap-switch/bootstrap-switch-tests.ts

@@ -0,0 +1,25 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="bootstrap-switch.d.ts" />
+
+function test_cases() {
+	$('#switch').bootstrapSwitch();
+	
+	$('#switch').bootstrapSwitch({
+		state: false
+	});
+
+	$('#switch').bootstrapSwitch({
+		state: false,
+		disabled: true
+	});
+
+	//var mySwitch = $('#switch').get(0);
+	//mySwitch.toggleAnimate();
+	
+	$('#switch').bootstrapSwitch('state', true, true);
+
+
+	$('#switch').on('switchChange.bootstrapSwitch', (event) => {
+		console.log($(event.target).val());
+	});
+}

bootstrap-switch/bootstrap-switch.d.ts

@@ -0,0 +1,102 @@
+// Type definitions for Bootstrap Switch
+// Project: http://www.bootstrap-switch.org/
+// Definitions by: John M. Baughman <https://github.com/johnmbaughman>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/**
+ * bootstrap-switch - v3.3.2 Copyright (c) 2012-2013 Mattia Larentis
+ * Available via the Apache license.
+ * see: http://www.bootstrap-switch.org/ or https://github.com/nostalgiaz/bootstrap-switch for details.
+ */
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare module BootstrapSwitch {
+    interface BootstrapSwitchChangeEventObject extends JQueryEventObject {
+        state: boolean
+    }
+
+    interface BootstrapSwitchEventObject extends JQueryEventObject { }
+
+    interface BootstrapSwitchOptions {
+        state?: boolean;
+        size?: string;
+        animate?: boolean;
+        disabled?: boolean;
+        readonly?: boolean;
+        indeterminate?: boolean;
+        invers?: boolean;
+        radioAllOff?: boolean;
+        onColor?: string;
+        offColor?: string;
+        onText?: string;
+        offText?: string;
+        labelText?: string;
+        handleWidth?: string;
+        labelWidth?: string;
+        baseClass?: string;
+        wrapperClass?: string;
+        onInit?: any;
+        onSwitchChange?: any;
+    }
+
+    interface Switch {
+        toggleAnimate(): JQuery;
+        toggleDisabled(): JQuery;
+        toggleReadonly(): JQuery;
+        toggleIndeterminate(): JQuery;
+        toggleInverse(): JQuery;
+        destroy(): JQuery;
+
+        state(): boolean;
+        state(value: any): JQuery;
+        state(value: any, skip: boolean): JQuery;
+        toggleState(skip?: boolean): JQuery;
+        radioAllOff(): boolean;
+        radioAllOff(state: boolean): JQuery;
+        size(): string;
+        size(size: string): JQuery;
+        animate(): boolean;
+        animate(state: boolean): JQuery;
+        disabled(): boolean;
+        disabled(state: boolean): JQuery;
+        toggleDisabled(): JQuery;
+        readonly(): boolean;
+        readonly(state: boolean): JQuery;
+        toggleReadOnly(): JQuery;
+        onColor(): string;
+        onColor(color: string): JQuery;
+        offColor(): string;
+        offColor(color: string): JQuery;
+        onText(): string;
+        onText(text: string): JQuery;
+        offText(): string;
+        offText(text: string): JQuery;
+        labelText(): string;
+        labelText(text: string): JQuery;
+        baseClass(): string;
+        baseClass(text: string): JQuery;
+        wrapperClass(): string;
+        wrapperClass(text: string): JQuery;
+    }
+}
+
+interface JQuery {
+    bootstrapSwitch(): JQuery;
+    bootstrapSwitch(options: BootstrapSwitch.BootstrapSwitchOptions): JQuery;
+    bootstrapSwitch(method: string): JQuery;
+    bootstrapSwitch(method: string, param: any): JQuery;
+    bootstrapSwitch(method: string, param1: any, param2: any): JQuery;
+
+    off(events: "init.bootstrapSwitch", selector?: string, handler?: (eventobject: BootstrapSwitch.BootstrapSwitchEventObject) => any): JQuery;
+    off(events: "init.bootstrapSwitch", handler?: (eventobject: BootstrapSwitch.BootstrapSwitchEventObject) => any): JQuery;
+
+    off(events: "switchChange.bootstrapSwitch", selector?: string, handler?: (eventobject: BootstrapSwitch.BootstrapSwitchChangeEventObject) => any): JQuery;
+    off(events: "switchChange.bootstrapSwitch", handler?: (eventobject: BootstrapSwitch.BootstrapSwitchChangeEventObject) => any): JQuery;
+
+    on(events: "init.bootstrapSwitch", selector?: string, handler?: (eventobject: BootstrapSwitch.BootstrapSwitchEventObject) => any): JQuery;
+    on(events: "init.bootstrapSwitch", handler?: (eventobject: BootstrapSwitch.BootstrapSwitchEventObject) => any): JQuery;
+
+    on(events: "switchChange.bootstrapSwitch", selector?: string, handler?: (eventobject: BootstrapSwitch.BootstrapSwitchChangeEventObject) => any): JQuery;
+    on(events: "switchChange.bootstrapSwitch", handler?: (eventobject: BootstrapSwitch.BootstrapSwitchChangeEventObject) => any): JQuery;
+}

bootstrap.datepicker/bootstrap.datepicker.d.ts

@@ -44,8 +44,8 @@ interface DatepickerEventObject extends JQueryEventObject {
 
 interface JQuery {
     datepicker(): JQuery;
-    datepicker(methodName: string): JQuery;
-    datepicker(methodName: string, params: any): JQuery;
+    datepicker(methodName: string): any;
+    datepicker(methodName: string, params: any): any;
     datepicker(options: DatepickerOptions): JQuery;
 
     off(events: "changeDate", selector?: string, handler?: (eventObject: DatepickerEventObject) => any): JQuery;

bootstrap/bootstrap-tests.ts

@@ -17,6 +17,7 @@ $('#myModal').modal('toggle');
 $('.dropdown-toggle').dropdown();
 
 $('#navbar').scrollspy();
+$('body').scrollspy({ target: '#navbar-example' });
 
 $('#element').tooltip('show');
 
@@ -42,4 +43,4 @@ $('.typeahead').typeahead({
     highlighter: item => ""
 });
 
-$('#navbar').affix();
+$('#navbar').affix();

bootstrap/bootstrap.d.ts

@@ -22,6 +22,7 @@ interface ModalOptionsBackdropString {
 
 interface ScrollSpyOptions {
     offset?: number;
+    target?: string;
 }
 
 interface TooltipOptions {

bounce/bounce-tests.ts

@@ -0,0 +1,77 @@
+/// <reference path="./bounce.d.ts" />
+/// <reference path="./../jquery/jquery.d.ts" />
+
+import Bounce from 'bounce.js';
+import * as $ from 'jquery';
+
+function test_chaining_transformations() {
+    var bounce = new Bounce();
+    bounce
+        .scale({
+            from: { x: 0, y: 0 },
+            to: { x: 2, y: 2 },
+            duration: 1000
+        })
+        .rotate({
+            from: 0,
+            to: 360,
+            delay: 500
+        })
+        .translate({
+            from: { x: 0, y: -100 },
+            to: { x: 0, y: 0 },
+            stiffness: 1,
+            bounces: 4
+        })
+        .skew({
+            from: { x: 1, y: 0.8 },
+            to: { x: 0.8, y: 1 },
+            easing: 'bounce'
+        });
+}
+
+function test_serialization() {
+    var b1 = new Bounce();
+    var serialized = b1.serialize();
+    var b2 = new Bounce();
+    b2.deserialize(serialized);
+}
+
+function test_apply () {
+    var bounce = new Bounce();
+    var element = document.createElement('div');
+    bounce.applyTo(element);
+    bounce.applyTo([element]);
+    bounce.applyTo($('div'));
+
+    var options = {
+        loop: true,
+        remove: true,
+        onComplete: () => {}
+    };
+    bounce.applyTo(element, options);
+    bounce.applyTo([element], options);
+    bounce.applyTo($('div'), options);
+}
+
+function test_apply_promise () {
+    var bounce = new Bounce();
+    var element = document.createElement('div');
+    bounce.applyTo($('div')).then(() => {});
+
+    var options = {
+        loop: true,
+        remove: true
+    };
+    bounce.applyTo($('div')).then(() => {});
+}
+
+function test_define() {
+    var bounce = new Bounce();
+    bounce.define('named-animation');
+}
+
+function test_remove() {
+    var bounce = new Bounce();
+    bounce.remove();
+}

bounce/bounce.d.ts

@@ -0,0 +1,66 @@
+// Type definitions for Bounce.js v0.8.2
+// Project: http://github.com/tictail/bounce.js
+// Definitions by: Cherry <http://github.com/cherrry>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare module 'bounce.js' {
+    export default Bounce
+
+    interface Point2D {
+        x: number
+        y: number
+    }
+
+    interface BounceOptions<T> {
+        from: T
+        to: T
+        duration?: number
+        delay?: number
+        easing?: string
+        bounces?: number
+        stiffness?: number
+    }
+
+    interface AnimationOptions {
+        loop?: boolean
+        remove?: boolean
+        onComplete?: () => void
+    }
+
+    interface SerailizedComponent<T> {
+        type: string
+        from: T
+        to: T
+        duration: number
+        delay: number
+        easing: string
+        bounces: number
+        stiffness: number
+    }
+
+    class Bounce {
+        static FPS: number
+        static counter: number
+
+        static isSupported(): boolean
+
+        constructor();
+
+        scale(options: BounceOptions<Point2D>): Bounce
+        rotate(options: BounceOptions<number>): Bounce
+        translate(options: BounceOptions<Point2D>): Bounce
+        skew(options: BounceOptions<Point2D>): Bounce
+
+        serialize(): SerailizedComponent<number|Point2D>[]
+        deserialize(serailized: SerailizedComponent<number|Point2D>[]): Bounce
+
+        applyTo(element: Element, options?: AnimationOptions): void
+        applyTo(elements: Element[], options?: AnimationOptions): void
+        applyTo(elements: JQuery, options?: AnimationOptions): JQueryPromise<void>
+
+        define(name: string): Bounce
+        remove(): void
+    }
+}

bowser/bowser-tests.ts

@@ -1,9 +1,9 @@
-/// <reference path="./bowser.d.ts" />
-
-import Bowser = require('bowser');
-
-Bowser.msedge === true;
-Bowser.test(['msie']) === true;
-Bowser.a === Bowser.c;
-Bowser.osversion > 10;
-Bowser.osversion === '10.1A';
+/// <reference path="./bowser.d.ts" />
+
+import Bowser = require('bowser');
+
+Bowser.msedge === true;
+Bowser.test(['msie']) === true;
+Bowser.a === Bowser.c;
+Bowser.osversion > 10;
+Bowser.osversion === '10.1A';

bowser/bowser.d.ts

@@ -1,54 +1,54 @@
-// Type definitions for Bowser 1.x
-// Project: https://github.com/ded/bowser
-// Definitions by: Paulo Cesar <https://github.com/pocesar>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-declare module 'bowser' {
-    var def: BowserModule.IBowser;
-    export = def;
-}
-
-declare module BowserModule {
-
-    export interface IBowserUA {
-        msie: boolean;
-        chrome: boolean;
-        webkit: boolean;
-        phantom: boolean;
-        opera: boolean;
-        safari: boolean;
-        android: boolean;
-        ios: boolean;
-        webos: boolean;
-        msedge: boolean;
-        seamonkey: boolean;
-        firefox: boolean;
-        yandexbrowser: boolean;
-        blackberry: boolean;
-        tablet: boolean;
-        mobile: boolean;
-        silk: boolean;
-        bada: boolean;
-        tizen: boolean;
-        windowsphone: boolean;
-        firefoxos: boolean;
-        gecko: boolean;
-        sailfish: boolean;
-        chromeBook: boolean;
-        /** Grade A browser */
-        a: boolean;
-        /** Grade C browser */
-        c: boolean;
-        /** Grade X browser */
-        x: boolean;
-        name: string;
-        version: string|number;
-        osversion: string|number;
-    }
-
-    export interface IBowser extends IBowserUA {
-        test(browserList: string[]): boolean;
-        _detect(ua: string): IBowser;
-    }
-
-}
+// Type definitions for Bowser 1.x
+// Project: https://github.com/ded/bowser
+// Definitions by: Paulo Cesar <https://github.com/pocesar>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'bowser' {
+    var def: BowserModule.IBowser;
+    export = def;
+}
+
+declare module BowserModule {
+
+    export interface IBowserUA {
+        msie: boolean;
+        chrome: boolean;
+        webkit: boolean;
+        phantom: boolean;
+        opera: boolean;
+        safari: boolean;
+        android: boolean;
+        ios: boolean;
+        webos: boolean;
+        msedge: boolean;
+        seamonkey: boolean;
+        firefox: boolean;
+        yandexbrowser: boolean;
+        blackberry: boolean;
+        tablet: boolean;
+        mobile: boolean;
+        silk: boolean;
+        bada: boolean;
+        tizen: boolean;
+        windowsphone: boolean;
+        firefoxos: boolean;
+        gecko: boolean;
+        sailfish: boolean;
+        chromeBook: boolean;
+        /** Grade A browser */
+        a: boolean;
+        /** Grade C browser */
+        c: boolean;
+        /** Grade X browser */
+        x: boolean;
+        name: string;
+        version: string|number;
+        osversion: string|number;
+    }
+
+    export interface IBowser extends IBowserUA {
+        test(browserList: string[]): boolean;
+        _detect(ua: string): IBowser;
+    }
+
+}

browser-sync/browser-sync-tests.ts

@@ -1,6 +1,13 @@
 /// <reference path="./browser-sync.d.ts"/>
 import browserSync = require("browser-sync");
 
+(() => {
+    //make sure that the interfaces are correctly exposed
+    var bsInstance: browserSync.BrowserSyncInstance;
+    var bsStatic: browserSync.BrowserSyncStatic;
+    var opts: browserSync.Options;
+})();
+
 browserSync({
     server: {
         baseDir: "./"
@@ -78,10 +85,13 @@ bs.init({
 });
 
 bs.reload();
-
-function browserSyncInit(): browserSync.BrowserSync {
+ 
+function browserSyncInit(): browserSync.BrowserSyncInstance {
     var browser = browserSync.create();
     browser.init();
+    console.log(browser.name);
+    console.log(browserSync.name);
     return browser;
 }
 var browser = browserSyncInit();
+browser.exit();

browser-sync/browser-sync.d.ts

@@ -1,6 +1,6 @@
 // Type definitions for browser-sync
 // Project: http://www.browsersync.io/
-// Definitions by: Asana <https://asana.com>
+// Definitions by: Asana <https://asana.com>, Joe Skeen <http://github.com/joeskeen>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
 /// <reference path="../chokidar/chokidar.d.ts"/>
@@ -11,107 +11,406 @@ declare module "browser-sync" {
     import fs = require("fs");
     import http = require("http");
 
-    interface Options {
-        files?: string | string[];
-        watchOptions?: GazeOptions;
-        server?: ServerOptions;
-        proxy?: string | boolean;
-        port?: number;
-        https?: boolean;
-        ghostMode?: GhostOptions | boolean;
-        logLevel?: string;
-        logPrefix?: string;
-        logConnections?: boolean;
-        logFileChanges?: boolean;
-        logSnippet?: boolean;
-        snippetOptions?: SnippetOptions;
-        rewriteRules?: boolean | RewriteRules[];
-        tunnel?: string | boolean;
-        online?: boolean;
-        open?: string | boolean;
-        browser?: string | string[];
-        xip?: boolean;
-        notify?: boolean;
-        scrollProportionally?: boolean;
-        scrollThrottle?: number;
-        reloadDelay?: number;
-        reloadDebounce?: number;
-        plugins?: any[];
-        injectChanges?: boolean;
-        startPath?: string;
-        minify?: boolean;
-        host?: string;
-        codeSync?: boolean;
-        timestamps?: boolean;
-        scriptPath?: (path: string) => string;
-        socket?: SocketOptions;
-    }
+    namespace browserSync {
+        interface Options {
+            /**
+             * Browsersync includes a user-interface that is accessed via a separate port. The UI allows to controls 
+             * all devices, push sync updates and much more.
+             * 
+             * port - Default: 3001
+             * weinre.port - Default: 8080
+             * Note: requires at least version 2.0.0
+             */
+            ui?: UIOptions;
+            /**
+             * Browsersync can watch your files as you work. Changes you make will either be injected into the page (CSS 
+             * & images) or will cause all browsers to do a full-page refresh. See anymatch for more information on glob
+             * patterns.
+             * Default: false
+             */
+            files?: string | string[];
+            /**
+             * File watching options that get passed along to Chokidar. Check their docs for available options
+             * Default: undefined
+             * Note: requires at least version 2.6.0
+             */
+            watchOptions?: ChokidarOptions;
+            /**
+             * Use the built-in static server for basic HTML/JS/CSS websites.
+             * Default: false
+             */
+            server?: ServerOptions;
+            /**
+             * Proxy an EXISTING vhost. Browsersync will wrap your vhost with a proxy URL to view your site.
+             * target - Default: undefined
+             * ws - Default: undefined
+             * middleware - Default: undefined
+             * reqHeaders - Default: undefined
+             * proxyRes - Default: undefined
+             */
+            proxy?: string | boolean | ProxyOptions;
+            /**
+             * Use a specific port (instead of the one auto-detected by Browsersync)
+             * Default: 3000
+             */
+            port?: number;
+            /**
+             * Add additional directories from which static files should be served. 
+             * Should only be used in proxy or snippet mode.
+             * Default: []
+             * Note: requires at least version 2.8.0
+             */
+            serveStatic?: string[];
+            /**
+             * Enable https for localhost development. 
+             * Note - this is not needed for proxy option as it will be inferred from your target url.
+             * Note: requires at least version 1.3.0
+             */
+            https?: boolean;
+            /**
+             * Clicks, Scrolls & Form inputs on any device will be mirrored to all others.
+             * clicks - Default: true
+             * scroll - Default: true
+             * forms - Default: true
+             */
+            ghostMode?: GhostOptions | boolean;
+            /**
+             * Can be either "info", "debug", "warn", or "silent"
+             * Default: info
+             */
+            logLevel?: string;
+            /**
+             * Change the console logging prefix. Useful if you're creating your own project based on Browsersync
+             * Default: BS
+             * Note: requires at least version 1.5.1
+             */
+            logPrefix?: string;
+            /**
+             * Whether or not to log connections
+             * Default: false
+             */
+            logConnections?: boolean;
+            /**
+             * Whether or not to log information about changed files
+             * Default: false
+             */
+            logFileChanges?: boolean;
+            /**
+             * Log the snippet to the console when you're in snippet mode (no proxy/server)
+             * Default: true
+             * Note: requires at least version 1.5.2
+             */
+            logSnippet?: boolean;
+            /**
+             * You can control how the snippet is injected onto each page via a custom regex + function. 
+             * You can also provide patterns for certain urls that should be ignored from the snippet injection.
+             * Note: requires at least version 2.0.0
+             */
+            snippetOptions?: SnippetOptions;
+            /**
+             * Add additional HTML rewriting rules.
+             * Default: false
+             * Note: requires at least version 2.4.0
+             */
+            rewriteRules?: boolean | RewriteRules[];
+            /**
+             * Tunnel the Browsersync server through a random Public URL
+             * Default: null
+             */
+            tunnel?: string | boolean;
+            /**
+             * Some features of Browsersync (such as xip & tunnel) require an internet connection, but if you're 
+             * working offline, you can reduce start-up time by setting this option to false
+             */
+            online?: boolean;
+            /**
+             * Default: true
+             * Decide which URL to open automatically when Browsersync starts. Defaults to "local" if none set. 
+             * Can be true, local, external, ui, ui-external, tunnel or false
+             */
+            open?: string | boolean;
+            /**
+             * The browser(s) to open
+             * Default: default
+             */
+            browser?: string | string[];
+            /**
+             * Requires an internet connection - useful for services such as Typekit as it allows you to configure 
+             * domains such as *.xip.io in your kit settings
+             * Default: false
+             */
+            xip?: boolean;
+            /**
+             * Reload each browser when Browsersync is restarted.
+             * Default: false
+             */
+            reloadOnRestart?: boolean;
+            /**
+             * The small pop-over notifications in the browser are not always needed/wanted.
+             * Default: true
+             */
+            notify?: boolean;
+            /**
+             * scrollProportionally: false // Sync viewports to TOP position
+             * Default: true
+             */
+            scrollProportionally?: boolean
+            /**
+             * How often to send scroll events
+             * Default: 0
+             */
+            scrollThrottle?: number;
+            /**
+             * Decide which technique should be used to restore scroll position following a reload. 
+             * Can be window.name or cookie
+             * Default: 'window.name'
+             */
+            scrollRestoreTechnique?: string;
+            /**
+             * Sync the scroll position of any element on the page. Add any amount of CSS selectors
+             * Default: []
+             * Note: requires at least version 2.9.0
+             */
+            scrollElements?: string[];
+            /**
+             * Default: []
+             * Note: requires at least version 2.9.0
+             * Sync the scroll position of any element on the page - where any scrolled element will cause 
+             * all others to match scroll position. This is helpful when a breakpoint alters which element 
+             * is actually scrolling
+             */
+            scrollElementMapping?: string[];
+            /**
+             * Time, in milliseconds, to wait before instructing the browser to reload/inject following a file 
+             * change event
+             * Default: 0
+             */
+            reloadDelay?: number;
+            /**
+             * Restrict the frequency in which browser:reload events can be emitted to connected clients
+             * Default: 0
+             * Note: requires at least version 2.6.0
+             */
+            reloadDebounce?: number;
+            /**
+             * User provided plugins
+             * Default: []
+             * Note: requires at least version 2.6.0
+             */
+            plugins?: any[];
+            /**
+             * Whether to inject changes (rather than a page refresh)
+             * Default: true
+             */
+            injectChanges?: boolean;
+            /**
+             * The initial path to load
+             */
+            startPath?: string;
+            /**
+             * Whether to minify the client script
+             * Default: true
+             */
+            minify?: boolean;
+            /**
+             * Override host detection if you know the correct IP to use
+             */
+            host?: string;
+            /**
+             * Send file-change events to the browser
+             * Default: true
+             */
+            codeSync?: boolean;
+            /**
+             * Append timestamps to injected files
+             * Default: true
+             */
+            timestamps?: boolean;
+            /**
+             * Alter the script path for complete control over where the Browsersync Javascript is served 
+             * from. Whatever you return from this function will be used as the script path.
+             * Note: requires at least version 1.5.0
+             */
+            scriptPath?: (path: string) => string;
+            /**
+             * Configure the Socket.IO path and namespace & domain to avoid collisions.
+             * path - Default: "/browser-sync/socket.io"
+             * clientPath - Default: "/browser-sync"
+             * namespace - Default: "/browser-sync"
+             * domain - Default: undefined
+             * port - Default: undefined
+             * clients.heartbeatTimeout - Default: 5000
+             * Note: requires at least version 1.6.2
+             */
+            socket?: SocketOptions;
+        }
 
-    interface GazeOptions {
-        interval?: number;
-        debounceDelay?: number;
-        mode?: string;
-        cwd?: string;
-    }
+        interface Hash<T> {
+            [path: string]: T;
+        }
 
-    interface ServerOptions {
-        baseDir?: string | string[];
-        directory?: boolean;
-        index?: string;
-        routes?: {[path: string]: string};
-        middleware?: MiddlewareHandler[];
-    }
+        interface ChokidarOptions {
+            interval?: number;
+            debounceDelay?: number;
+            mode?: string;
+            cwd?: string;
+        }
 
-    interface MiddlewareHandler {
-        (req: http.ServerRequest, res: http.ServerResponse, next: Function): any;
-    }
+        interface UIOptions { 
+            /** set the default port */
+            port?: number;
+            /** set the default weinre port */
+            weinre?: {
+                port?: number;
+            };
+        }
 
-    interface GhostOptions {
-        clicks?: boolean;
-        scroll?: boolean;
-        forms?: boolean;
-    }
+        interface ServerOptions {
+            /** set base directory */
+            baseDir?: string | string[];
+            /** enable directory listing */
+            directory?: boolean;
+            /** set index filename */
+            index?: string;
+            /** 
+             * key-value object hash, where the key is the url to match, 
+             * and the value is the folder to serve (relative to your working directory) 
+             */
+            routes?: Hash<string>;
+            /** configure custom middleware */
+            middleware?: MiddlewareHandler[];
+        }
 
-    interface SnippetOptions {
-        ignorePaths?: string;
-        rule?: {match?: RegExp; fn?: (snippet: string, match: string) => any};
-    }
+        interface ProxyOptions {
+            target?: string;
+            middleware?: MiddlewareHandler;
+            ws: boolean;
+            reqHeaders: (config: any) => Hash<any>;
+            proxyRes: (res: http.ServerResponse, req: http.ServerRequest, next: Function) => any;
+        }
 
-    interface SocketOptions {
-        path?: string;
-        clientPath?: string;
-        namespace?: string;
-    }
+        interface MiddlewareHandler {
+            (req: http.ServerRequest, res: http.ServerResponse, next: Function): any;
+        }
 
-    interface RewriteRules {
-        match: RegExp;
-        fn: (match: string) => string;
-    }
+        interface GhostOptions {
+            clicks?: boolean;
+            scroll?: boolean;
+            forms?: boolean;
+        }
 
-    module browserSync {
-        interface BrowserSync {
-            init(config?: Options, callback?: (err: Error, bs: Object) => any): void;
+        interface SnippetOptions {
+            ignorePaths?: string;
+            rule?: { match?: RegExp; fn?: (snippet: string, match: string) => any };
+        }
+
+        interface SocketOptions {
+            path?: string;
+            clientPath?: string;
+            namespace?: string;
+            domain?: string;
+            port?: number;
+            clients?: { heartbeatTimeout?: number; };
+        }
+
+        interface RewriteRules {
+            match: RegExp;
+            fn: (match: string) => string;
+        }
+
+        interface BrowserSyncStatic extends BrowserSyncInstance {
+            /**
+             * Start the Browsersync service. This will launch a server, proxy or start the snippet mode 
+             * depending on your use-case.
+             */
+            (config?: Options, callback?: (err: Error, bs: Object) => any): BrowserSyncInstance;
+            /**
+             * Create a Browsersync instance
+             * @param name an identifier that can used for retrieval later
+             */
+            create(name?: string): BrowserSyncInstance;
+            /**
+             * Get a single instance by name. This is useful if you have your build scripts in separate files
+             * @param name the identifier used for retrieval
+             */
+            get(name: string): BrowserSyncInstance;
+        }
+
+        interface BrowserSyncInstance {
+            /** the name of this instance of browser-sync */
+            name: string;
+            /**
+             * Start the Browsersync service. This will launch a server, proxy or start the snippet mode 
+             * depending on your use-case.
+             */
+            init(config?: Options, callback?: (err: Error, bs: Object) => any): BrowserSyncInstance;
+            /**
+             * Reload the browser
+             * The reload method will inform all browsers about changed files and will either cause the browser 
+             * to refresh, or inject the files where possible.
+             */
             reload(): void;
+            /**
+             * Reload a single file
+             * The reload method will inform all browsers about changed files and will either cause the browser 
+             * to refresh, or inject the files where possible.
+             */
             reload(file: string): void;
+            /**
+             * Reload multiple files
+             * The reload method will inform all browsers about changed files and will either cause the browser 
+             * to refresh, or inject the files where possible.
+             */
             reload(files: string[]): void;
-            reload(options: {stream: boolean}): NodeJS.ReadWriteStream;
+            /**
+             * The reload method will inform all browsers about changed files and will either cause the browser 
+             * to refresh, or inject the files where possible.
+             */
+            reload(options: { stream: boolean }): NodeJS.ReadWriteStream;
+            /**
+             * The stream method returns a transform stream and can act once or on many files.
+             * @param opts Configuration for the stream method
+             */
+            stream(opts: { once: boolean }): NodeJS.ReadWriteStream;
+            /**
+             * Helper method for browser notifications
+             * @param message Can be a simple message such as 'Connected' or HTML
+             * @param timeout How long the message will remain in the browser. @since 1.3.0
+             */
             notify(message: string, timeout?: number): void;
+            /**
+             * This method will close any running server, stop file watching & exit the current process.
+             */
             exit(): void;
-            watch(patterns: string, opts?: chokidar.WatchOptions, fn?: (event: string, file: fs.Stats) => any): NodeJS.EventEmitter;
+            /**
+             * Stand alone file-watcher. Use this along with Browsersync to create your own, minimal build system
+             */
+            watch(patterns: string, opts?: chokidar.WatchOptions, fn?: (event: string, file: fs.Stats) => any)
+                : NodeJS.EventEmitter;
+            /**
+             * Method to pause file change events
+             */
             pause(): void;
+            /**
+             * Method to resume paused watchers
+             */
             resume(): void;
+            /**
+             * The internal Event Emitter used by the running Browsersync instance (if there is one). You can use 
+             * this to emit your own events, such as changed files, logging etc.
+             */
             emitter: NodeJS.EventEmitter;
+            /**
+             * A simple true/false flag that you can use to determine if there's a currently-running Browsersync instance.
+             */
             active: boolean;
+            /**
+             * A simple true/false flag to determine if the current instance is paused
+             */
             paused: boolean;
         }
     }
 
-    interface Exports extends browserSync.BrowserSync {
-        create(): browserSync.BrowserSync;
-        (config?: Options, callback?: (err: Error, bs: Object) => any): void;
-    }
-
-    var browserSync: Exports;
-
+    const browserSync: browserSync.BrowserSyncStatic;
     export = browserSync;
 }

bytes/bytes-tests.ts

@@ -0,0 +1,16 @@
+/// <reference path="./bytes.d.ts"/>
+
+import bytes = require('bytes');
+
+// 1024*1024 = 1048576
+console.log(bytes(104857));
+console.log(bytes(104857, { thousandsSeparator: ' ' }));
+
+console.log(bytes.format(104857));
+console.log(bytes.format(104857, { thousandsSeparator: ' ' }));
+
+console.log(bytes('1024kb'));
+console.log(bytes(1024));
+
+console.log(bytes.parse('1024kb'));
+console.log(bytes.parse(1024));

bytes/bytes.d.ts

@@ -0,0 +1,62 @@
+// Type definitions for bytes v2.1.0
+// Project: https://github.com/visionmedia/bytes.js
+// Definitions by: Zhiyuan Wang <https://github.com/danny8002/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module 'bytes' {
+
+    /**
+     *Convert the given value in bytes into a string.
+     *
+     * @param {number} value
+     * @param {{
+     *  thousandsSeparator: [string]
+     *  }} [options] bytes options.
+     *
+     * @returns {string}
+     */
+    function bytes(value: number, options?: { thousandsSeparator: string }): string;
+
+    /**
+     *Parse string to an integer in bytes.
+     *
+     * @param {string} value
+     * @returns {number}
+     */
+    function bytes(value: string): number;
+
+    module bytes {
+
+        /**
+         * Format the given value in bytes into a string.
+         * 
+         * If the value is negative, take Math.abs(). If it is a float,
+         * it is rounded.
+         * 
+         * @param {number} value
+         * @param {BytesFormatOptions} [options]
+         */
+
+        function format(value: number, options?: { thousandsSeparator: string }): string;
+
+        /**
+         * Just return the input number value.
+         * 
+         * @param {number} value
+         * @return {number}
+         */
+        function parse(value: number): number;
+
+        /**
+         * Parse the string value into an integer in bytes.
+         * 
+         * If no unit is given, it is assumed the value is in bytes.
+         * 
+         * @param {string} value
+         * @return {number}
+         */
+        function parse(value: string): number;
+    }
+
+    export = bytes;
+}