diff --git a/parse/parse-tests.ts b/parse/parse-tests.ts
new file mode 100644
index 000000000..6316aaf17
--- /dev/null
+++ b/parse/parse-tests.ts
@@ -0,0 +1,519 @@
+/// <reference path="parse.d.ts" />
+
+function test_events() {
+
+    var object = new Parse.Events();
+    object.on("alert", (eventName: string) => alert("Triggered " + eventName));
+
+    object.trigger("alert", "an event");
+
+    var onChange = () => console.log('whatever');
+    var context: any;
+
+    object.off("change", onChange);
+    object.off("change");
+    object.off(null, onChange);
+    object.off(null, null, context);
+    object.off();
+}
+
+class GameScore extends Parse.Object {
+
+    constructor(options?: any) {
+
+        super("GameScore", options);
+    }
+}
+
+class Game extends Parse.Object {
+
+    constructor(options?: any) {
+
+        super("GameScore", options);
+    }
+
+    set score(score: GameScore)  {
+        this.set('score', score);
+    }
+
+    get score(): GameScore {
+        return this.get("gameScore");
+    }
+}
+
+function test_object() {
+
+    var game = new Game();
+
+// Create a new instance of that class.
+    var gameScore = new GameScore();
+
+    gameScore.set("score", 1337);
+    gameScore.set("playerName", "Sean Plott");
+    gameScore.set("cheatMode", false);
+
+
+    var score = gameScore.get("score");
+    var playerName = gameScore.get("playerName");
+    var cheatMode = gameScore.get("cheatMode");
+
+    gameScore.increment("score");
+    gameScore.addUnique("skills", "flying");
+    gameScore.addUnique("skills", "kungfu");
+
+    game.set("gameScore", gameScore);
+    game.score = gameScore;
+
+    var newGameScore = game.score;
+
+    game.save(null, {
+        success: (game) => {
+            // Execute any logic that should take place after the object is saved.
+            console.log('New object created with objectId: ' + game.id);
+        },
+        error: (game, error) => {
+            // Execute any logic that should take place if the save fails.
+            // error is a Parse.Error with an error code and description.
+            console.log('Fa iled to create new object, with error code: ' + error.message);
+        }
+    }).then(
+
+        (response) => {
+
+            console.log(response);
+        },
+        (error) => {
+
+            console.log(error);
+        }
+    );
+
+    game.fetch().then(
+
+        (response) => {
+
+            console.log(response);
+        },
+        (error) => {
+
+            console.log(error);
+        }
+    );
+
+    game.destroy().then(
+
+        (response) => {
+
+            console.log(response);
+        },
+        (error) => {
+
+            console.log(error);
+        }
+    );
+}
+
+function test_query() {
+
+    var gameScore = new GameScore();
+
+    var query = new Parse.Query(GameScore);
+    query.equalTo("playerName", "Dan Stemkoski");
+    query.notEqualTo("playerName", "Michael Yabuti");
+    query.greaterThan("playerAge", 18);
+    query.limit(10);
+    query.skip(10);
+
+    // Sorts the results in ascending order by the score field
+    query.ascending("score");
+
+    // Sorts the results in descending order by the score field
+    query.descending("score");
+
+    // Restricts to wins < 50
+    query.lessThan("wins", 50);
+
+    // Restricts to wins <= 50
+    query.lessThanOrEqualTo("wins", 50);
+
+    // Restricts to wins > 50
+    query.greaterThan("wins", 50);
+
+    // Restricts to wins >= 50
+    query.greaterThanOrEqualTo("wins", 50);
+
+    // Finds scores from any of Jonathan, Dario, or Shawn
+    query.containedIn("playerName",
+                      ["Jonathan Walsh", "Dario Wunsch", "Shawn Simon"]);
+
+    // Finds scores from anyone who is neither Jonathan, Dario, nor Shawn
+    query.notContainedIn("playerName",
+                         ["Jonathan Walsh", "Dario Wunsch", "Shawn Simon"]);
+
+    // Finds objects that have the score set
+    query.exists("score");
+
+    // Finds objects that don't have the score set
+    query.doesNotExist("score");
+    query.matchesKeyInQuery("hometown", "city", query);
+    query.doesNotMatchKeyInQuery("hometown", "city", query);
+    query.select("score", "playerName");
+
+    // Find objects where the array in arrayKey contains 2.
+    query.equalTo("arrayKey", 2);
+
+    // Find objects where the array in arrayKey contains all of the elements 2, 3, and 4.
+    query.containsAll("arrayKey", [2, 3, 4]);
+
+    query.startsWith("name", "Big Daddy's");
+    query.equalTo("score", gameScore);
+    query.exists("score");
+    query.include("score");
+    query.include(["score.team"]);
+
+    var testQuery = Parse.Query.or(query, query);
+
+    query.count().then(
+        (object) => {
+
+        },
+        (error) => {
+            console.log("Error: " + error.code + " " + error.message);
+        }
+    );
+
+    query.find({
+       success: (results) => {
+           alert("Successfully retrieved " + results.length + " scores.");
+           // Do something with the returned Parse.Object values
+           for (var i = 0; i < results.length; i++) {
+               var object = results[i];
+               console.log(object.id + ' - ' + object.get('playerName'));
+           }
+       },
+       error: (error) => {
+           alert("Error: " + error.code + " " + error.message);
+       }
+   });
+
+    query.first().then(
+        (object) => {
+
+        },
+        (error) => {
+            console.log("Error: " + error.code + " " + error.message);
+        }
+    );
+}
+
+class TestCollection extends Parse.Collection<Object> {
+
+    constructor(models?: Parse.Object[]) {
+
+        super(models);
+    }
+}
+
+function test_collections() {
+
+    var collection = new TestCollection();
+
+    var query = new Parse.Query(Game);
+    query.equalTo("temperature", "hot");
+    query.greaterThan("degreesF", 100);
+
+    collection = query.collection();
+
+    collection.comparator = (object) => {
+        return object.get("temperature");
+    };
+
+    collection.add([
+       {"name": "Duke"},
+       {"name": "Scarlett"}
+   ]);
+
+    collection.fetch().then(
+        (data) => {
+
+        },
+        (error) => {
+            console.log("Error: " + error.code + " " + error.message);
+        }
+    );
+
+    var model = collection.at(0);
+
+    // Or you can get it by Parse objectId.
+    var modelAgain = collection.get(model.id);
+
+    // Remove "Duke" from the collection.
+    collection.remove(model);
+
+    // Completely replace all items in the collection.
+    collection.reset([
+         {"name": "Hawk"},
+         {"name": "Jane"}
+     ]);
+}
+
+function test_file() {
+
+    var base64 = "V29ya2luZyBhdCBQYXJzZSBpcyBncmVhdCE=";
+    var file = new Parse.File("myfile.txt", { base64: base64 });
+
+    var bytes = [ 0xBE, 0xEF, 0xCA, 0xFE ];
+    var file = new Parse.File("myfile.txt", bytes);
+
+    var file = new Parse.File("myfile.zzz", {}, "image/png");
+
+    var src = file.url();
+
+    file.save().then(
+    () => {
+        // The file has been saved to Parse.
+    },
+    (error) => {
+        // The file either could n ot be read, or could not be saved to Parse.
+    });
+
+    Parse.Cloud.httpRequest({ url: file.url() }).then((response: Parse.Promise<Parse.Cloud.HttpResponse>) => {
+        // result
+    });
+
+    // TODO: Check
+}
+
+function test_analytics() {
+
+    var dimensions = {
+        // Define  ranges to bucket data points into meaningful segments
+        priceRange: '1000-1500',
+        // Did the user filter the query?
+        source: 'craigslist',
+        // Do searches happen more often on weekdays or weekends?
+        dayType: 'weekday'
+    };
+   // Send the dimensions to Parse along with the 'search' event
+    Parse.Analytics.track('search', dimensions);
+
+    var codeString = '404';
+    Parse.Analytics.track('error', { code: codeString })
+}
+
+function test_user_acl_roles() {
+
+    var user = new Parse.User();
+    user.set("username", "my name");
+    user.set("password", "my pass");
+    user.set("email", "email@example.com");
+
+// other fields can be set just like with Parse.Object
+    user.set("phone", "415-392-0202");
+
+    user.signUp(null, {
+        success: function(user) {
+            // Hooray! Let them use the app now.
+        },
+        error: function(user, error) {
+            // Show the error message somewhere and let the user try again.
+            alert("Error: " + error.code + " " + error.message);
+        }
+    });
+
+    Parse.User.logIn("myname", "mypass").then(
+        (data) => {
+
+        },
+        (error) => {
+            console.log("Error: " + error.code + " " + error.message);
+        }
+    );
+
+    var currentUser = Parse.User.current();
+    if (currentUser) {
+        // do stuff with the user
+    } else {
+        // show the signup or login page
+    }
+
+    Parse.User.become("session-token-here").then(function (user) {
+        // The current user is now set to user.
+    }, function (error) {
+        // The token could not be validated.
+    });
+
+    var game = new Game();
+    game.set("score", new GameScore());
+    game.setACL(new Parse.ACL(Parse.User.current()));
+    game.save();
+
+    var groupACL = new Parse.ACL();
+
+    var userList = [];
+    // userList is an array with the users we are sending this message to.
+    for (var i = 0; i < userList.length; i++) {
+        groupACL.setReadAccess(userList[i], true);
+        groupACL.setWriteAccess(userList[i], true);
+    }
+
+    groupACL.setPublicReadAccess(true);
+
+    game.setACL(groupACL);
+
+    Parse.User.requestPasswordReset("email@example.com").then(function (data) {
+        // The current user is now set to user.
+    }, function (error) {
+        // The token could not be validated.
+    });
+
+    // By specifying no write privileges for the ACL, we can ensure the role cannot be altered.
+    var role = new Parse.Role("Administrator", groupACL);
+    role.getUsers().add(role);
+    role.getRoles().add(role);
+    role.save();
+
+    Parse.User.logOut();
+}
+
+function test_facebook_util() {
+
+    Parse.FacebookUtils.init({
+         appId      : 'YOUR_APP_ID', // Facebook App ID
+         channelUrl : '//WWW.YOUR_DOMAIN.COM/channel.html', // Channel File
+         cookie     : true, // enable cookies to allow Parse to access the session
+         xfbml      : true  // parse XFBML
+     });
+
+    Parse.FacebookUtils.logIn(null, {
+        success: (user) => {
+            if (!user.existed()) {
+                alert("User signed up and logged in through Facebook!");
+            } else {
+                alert("User logged in through Facebook!");
+            }
+        },
+        error: (user, error) => {
+            alert("User cancelled the Facebook login or did not fully authorize.");
+        }
+    });
+
+    var user = Parse.User.current();
+
+    if (!Parse.FacebookUtils.isLinked(user)) {
+        Parse.FacebookUtils.link(user, null, {
+            success: (user) => {
+                alert("Woohoo, user logged in with Facebook!");
+            },
+            error: (user, error) => {
+                alert("User cancelled the Facebook login or did not fully authorize.");
+            }
+        });
+    }
+
+    Parse.FacebookUtils.unlink(user, {
+        success: (user) => {
+            alert("The user is no longer associated with their Facebook account.");
+        }
+    });
+}
+
+function test_cloud_functions() {
+
+    Parse.Cloud.run('hello', {}, {
+        success: (result) => {
+            // result
+        },
+        error: (error) => {
+        }
+    });
+
+    Parse.Cloud.afterDelete('MyCustomClass', (request: Parse.Cloud.AfterDeleteRequest) => {
+        // result
+    });
+
+    Parse.Cloud.afterSave('MyCustomClass', (request: Parse.Cloud.AfterSaveRequest) => {
+        // result
+    });
+
+    Parse.Cloud.beforeDelete('MyCustomClass', (request: Parse.Cloud.BeforeDeleteRequest,
+                                               response: Parse.Cloud.BeforeDeleteResponse) => {
+        // result
+    });
+}
+
+class PlaceObject extends Parse.Object {}
+
+function test_geo_points() {
+
+    var point = new Parse.GeoPoint({latitude: 40.0, longitude: -30.0});
+
+    var userObject = Parse.User.current();
+
+    // User's location
+    var userGeoPoint = userObject.get("location");
+
+    // Create a query for places
+    var query = new Parse.Query(Parse.User);
+// Interested in locations near user.
+    query.near("location", userGeoPoint);
+        // Limit what could be a lot of points.
+    query.limit(10);
+    // Final list of objects
+    query.find({
+       success: (placesObjects) => {
+       }
+   });
+
+
+    var southwestOfSF = new Parse.GeoPoint(37.708813, -122.526398);
+    var northeastOfSF = new Parse.GeoPoint(37.822802, -122.373962);
+
+    var query = new Parse.Query(PlaceObject);
+    query.withinGeoBox("location", southwestOfSF, northeastOfSF);
+    query.find({
+       success: function(place) {
+
+       }
+   });
+}
+
+function test_push() {
+
+    Parse.Push.send({
+        channels: [ "Gia nts", "Mets" ],
+        data: {
+            alert: "The Giants won against the Mets 2-3."
+        }
+    }, {
+        success: () => {
+            // Push was successful
+        },
+        error: (error) => {
+            // Handle error
+        }
+    });
+
+    var query = new Parse.Query(Parse.Installation);
+    query.equalTo('injuryReports', true);
+
+    Parse.Push.send({
+        where: query, // Set our Installation query
+        data: {
+            alert: "Willie Hayes injured by own pop fly."
+        }
+    }, {
+        success: function() {
+            // Push was successful
+        },
+        error: function(error) {
+            // Handle error
+        }
+    });
+}
+
+function test_view() {
+
+    var model = Parse.User.current();
+    var view = new Parse.View<Parse.User>();
+}
\ No newline at end of file
diff --git a/parse/parse.d.ts b/parse/parse.d.ts
new file mode 100644
index 000000000..697e3bf87
--- /dev/null
+++ b/parse/parse.d.ts
@@ -0,0 +1,943 @@
+// Type definitions for Parse v1.2.19
+// Project: https://parse.com/
+// Definitions by: Ullisen Media Group, LLC <[http://ullisenmedia.com]>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/// <reference path="../node/node.d.ts" />
+/// <reference path="../jquery/jquery.d.ts" />
+/// <reference path="../underscore/underscore.d.ts" />
+
+declare module Parse {
+
+    var applicationId: string;
+    var javaScriptKey: string;
+    var masterKey: string;
+    var serverURL: string;
+    var VERSION: string;
+
+    interface ParseDefaultOptions {
+        wait?: boolean;
+        silent?: boolean;
+        success?: Function;
+        error?: Function;
+        useMasterKey?: boolean;
+    }
+
+    interface CollectionOptions {
+        model?: Object;
+        query?: Query;
+        comparator?: string;
+    }
+
+    interface CollectionAddOptions {
+        at?: number;
+    }
+
+    interface RouterOptions {
+        routes: any;
+    }
+
+    interface NavigateOptions {
+        trigger?: boolean;
+    }
+
+    interface ViewOptions {
+        model?: any;
+        collection?: any;
+        el?: any;
+        id?: string;
+        className?: string;
+        tagName?: string;
+        attributes?: any[];
+    }
+
+    interface PushData {
+        channels?: string[];
+        push_time?: Date;
+        expiration_time?: Date;
+        expiration_interval?: number;
+        where?: Query;
+        data?: any;
+        alert?: string;
+        badge?: string;
+        sound?: string;
+        title?: string;
+    }
+
+    /**
+     * A Promise is returned by async methods as a hook to provide callbacks to be
+     * called when the async task is fulfilled.
+     *
+     * <p>Typical usage would be like:<pre>
+     *    query.find().then(function(results) {
+     *      results[0].set("foo", "bar");
+     *      return results[0].saveAsync();
+     *    }).then(function(result) {
+     *      console.log("Updated " + result.id);
+     *    });
+     * </pre></p>
+     *
+     * @see Parse.Promise.prototype.then
+     * @class
+     */
+
+    interface IPromise<T> {
+
+        then<U>(resolvedCallback: (value: T) => IPromise<U>, rejectedCallback?: (reason: any) => IPromise<U>): IPromise<T>;
+        then<U>(resolvedCallback: (value: T) => U, rejectedCallback?: (reason: any) => IPromise<U>): IPromise<U>;
+        then<U>(resolvedCallback: (value: T) => U, rejectedCallback?: (reason: any) => U): IPromise<U>;
+    }
+
+    interface Promise<T> {
+
+        always(callback: Function): Promise<T>;
+        as(): Promise<T>;
+        done(callback: Function): Promise<T>;
+        error(): Promise<T>;
+        fail(callback: Function): Promise<T>;
+        is(): Promise<T>;
+        reject(error: any): void;
+        resolve(result: any): void;
+        then<U>(resolvedCallback: (value: T) => Promise<U>,
+                rejectedCallback?: (reason: any) => Promise<U>): IPromise<T>;
+        then<U>(resolvedCallback: (value: T) => U,
+            rejectedCallback?: (reason: any) => IPromise<U>): IPromise<T>;
+        then<U>(resolvedCallback: (value: T) => U,
+            rejectedCallback?: (reason: any) => U): IPromise<T>;
+
+        when(promises: Promise<T>[]): Promise<T>;
+    }
+
+    interface IBaseObject {
+        toJSON(): any;
+    }
+
+    class BaseObject implements IBaseObject {
+        toJSON(): any;
+    }
+
+    /**
+     * Creates a new ACL.
+     * If no argument is given, the ACL has no permissions for anyone.
+     * If the argument is a Parse.User, the ACL will have read and write
+     *   permission for only that user.
+     * If the argument is any other JSON object, that object will be interpretted
+     *   as a serialized ACL created with toJSON().
+     * @see Parse.Object#setACL
+     * @class
+     *
+     * <p>An ACL, or Access Control List can be added to any
+     * <code>Parse.Object</code> to restrict access to only a subset of users
+     * of your application.</p>
+     */
+    class ACL extends BaseObject {
+
+        permissionsById: any;
+
+        constructor(arg1?: any);
+
+        setPublicReadAccess(allowed: boolean);
+        getPublicReadAccess(): boolean;
+
+        setPublicWriteAccess(allowed: boolean);
+        getPublicWriteAccess(): boolean;
+
+        setReadAccess(userId: User, allowed: boolean);
+        getReadAccess(userId: User): boolean;
+
+        setReadAccess(userId: string, allowed: boolean);
+        getReadAccess(userId: string): boolean;
+
+        setRoleReadAccess(role: Role, allowed: boolean);
+        setRoleReadAccess(role: string, allowed: boolean);
+        getRoleReadAccess(role: Role): boolean;
+        getRoleReadAccess(role: string): boolean;
+
+        setRoleWriteAccess(role: Role, allowed: boolean);
+        setRoleWriteAccess(role: string, allowed: boolean);
+        getRoleWriteAccess(role: Role): boolean;
+        getRoleWriteAccess(role: string): boolean;
+
+        setWriteAccess(userId: User, allowed: boolean);
+        setWriteAccess(userId: string, allowed: boolean);
+        getWriteAccess(userId: User): boolean;
+        getWriteAccess(userId: string): boolean;
+    }
+
+
+    /**
+     * A Parse.File is a local representation of a file that is saved to the Parse
+     * cloud.
+     * @class
+     * @param name {String} The file's name. This will be prefixed by a unique
+     *     value once the file has finished saving. The file name must begin with
+     *     an alphanumeric character, and consist of alphanumeric characters,
+     *     periods, spaces, underscores, or dashes.
+     * @param data {Array} The data for the file, as either:
+     *     1. an Array of byte value Numbers, or
+     *     2. an Object like { base64: "..." } with a base64-encoded String.
+     *     3. a File object selected with a file upload control. (3) only works
+     *        in Firefox 3.6+, Safari 6.0.2+, Chrome 7+, and IE 10+.
+     *        For example:<pre>
+     * var fileUploadControl = $("#profilePhotoFileUpload")[0];
+     * if (fileUploadControl.files.length > 0) {
+     *   var file = fileUploadControl.files[0];
+     *   var name = "photo.jpg";
+     *   var parseFile = new Parse.File(name, file);
+     *   parseFile.save().then(function() {
+     *     // The file has been saved to Parse.
+     *   }, function(error) {
+     *     // The file either could not be read, or could not be saved to Parse.
+     *   });
+     * }</pre>
+     * @param type {String} Optional Content-Type header to use for the file. If
+     *     this is omitted, the content type will be inferred from the name's
+     *     extension.
+     */
+     class File {
+
+        constructor(name: string, data: any, type?: string);
+        name(): string;
+        url(): string;
+        save(options?: ParseDefaultOptions);
+
+    }
+
+    /**
+     * Creates a new GeoPoint with any of the following forms:<br>
+     *   <pre>
+     *   new GeoPoint(otherGeoPoint)
+     *   new GeoPoint(30, 30)
+     *   new GeoPoint([30, 30])
+     *   new GeoPoint({latitude: 30, longitude: 30})
+     *   new GeoPoint()  // defaults to (0, 0)
+     *   </pre>
+     * @class
+     *
+     * <p>Represents a latitude / longitude point that may be associated
+     * with a key in a ParseObject or used as a reference point for geo queries.
+     * This allows proximity-based queries on the key.</p>
+     *
+     * <p>Only one key in a class may contain a GeoPoint.</p>
+     *
+     * <p>Example:<pre>
+     *   var point = new Parse.GeoPoint(30.0, -20.0);
+     *   var object = new Parse.Object("PlaceObject");
+     *   object.set("location", point);
+     *   object.save();</pre></p>
+     */
+    class GeoPoint extends BaseObject {
+
+        latitude: number;
+        longitude: number;
+
+        constructor(arg1?: any, arg2?: any);
+
+        current(options?: ParseDefaultOptions): GeoPoint;
+        radiansTo(point: GeoPoint): number;
+        kilometersTo(point: GeoPoint): number;
+        milesTo(point: GeoPoint): number;
+    }
+
+    /**
+     * History serves as a global router (per frame) to handle hashchange
+     * events or pushState, match the appropriate route, and trigger
+     * callbacks. You shouldn't ever have to create one of these yourself
+     * — you should use the reference to <code>Parse.history</code>
+     * that will be created for you automatically if you make use of
+     * Routers with routes.
+     * @class
+     *
+     * <p>A fork of Backbone.History, provided for your convenience.  If you
+     * use this class, you must also include jQuery, or another library
+     * that provides a jQuery-compatible $ function.  For more information,
+     * see the <a href="http://documentcloud.github.com/backbone/#History">
+     * Backbone documentation</a>.</p>
+     * <p><strong><em>Available in the client SDK only.</em></strong></p>
+     */
+    class History {
+
+        handlers: any[];
+        interval: number;
+        fragment: string;
+
+        checkUrl(e?: any): void;
+        getFragment(fragment?: string, forcePushState?: boolean): string;
+        getHash(windowOverride: Window): string;
+        loadUrl(fragmentOverride: any): boolean;
+        navigate(fragment: string, options?: any): any;
+        route(route: any, callback: Function): void;
+        start(options: any): boolean;
+        stop(): void;
+    }
+
+    /**
+     * A class that is used to access all of the children of a many-to-many relationship.
+     * Each instance of Parse.Relation is associated with a particular parent object and key.
+     */
+    class Relation extends BaseObject {
+
+        parent: Object;
+        key: string;
+        targetClassName: string;
+
+        constructor(parent?: Object, key?: string);
+
+        //Adds a Parse.Object or an array of Parse.Objects to the relation.
+        add(object: Object): void;
+
+        // Returns a Parse.Query that is limited to objects in this relation.
+        query(): Query;
+
+        // Removes a Parse.Object or an array of Parse.Objects from this relation.
+        remove(object: Object): void;
+    }
+
+    /**
+     * Creates a new model with defined attributes. A client id (cid) is
+     * automatically generated and assigned for you.
+     *
+     * <p>You won't normally call this method directly.  It is recommended that
+     * you use a subclass of <code>Parse.Object</code> instead, created by calling
+     * <code>extend</code>.</p>
+     *
+     * <p>However, if you don't want to use a subclass, or aren't sure which
+     * subclass is appropriate, you can use this form:<pre>
+     *     var object = new Parse.Object("ClassName");
+     * </pre>
+     * That is basically equivalent to:<pre>
+     *     var MyClass = Parse.Object.extend("ClassName");
+     *     var object = new MyClass();
+     * </pre></p>
+     *
+     * @param {Object} attributes The initial set of data to store in the object.
+     * @param {Object} options A set of Backbone-like options for creating the
+     *     object.  The only option currently supported is "collection".
+     * @see Parse.Object.extend
+     *
+     * @class
+     *
+     * <p>The fundamental unit of Parse data, which implements the Backbone Model
+     * interface.</p>
+     */
+    class Object extends BaseObject {
+
+        id: any;
+        attributes: any;
+        cid: string;
+        changed: boolean;
+        className: string;
+
+        constructor(className?: string, options?: any);
+        constructor(attributes?: string[], options?: any);
+
+        static extend(className: string, protoProps?: any, classProps?: any): any;
+        static fetchAll<T>(list: Object[], options: ParseDefaultOptions): Promise<T>;
+        static fetchAllIfNeeded<T>(list: Object[], options: ParseDefaultOptions): Promise<T>;
+
+        initialize();
+        add(attr: string, item: any);
+        addUnique(attr: string, item: any);
+        change(options: any);
+        changedAttributes(diff: any): any;
+        clear(options: any): any;
+        clone(): Object;
+        destroy<T>(options?: ParseDefaultOptions): Promise<T>;
+        destroyAll<T>(list: Object[], options?: ParseDefaultOptions): Promise<T>;
+        dirty(attr: String): boolean;
+        dirtyKeys(): string[];
+        escape(attr: string);
+        existed(): boolean;
+        fetch<T>(options?: ParseDefaultOptions): Promise<T>;
+        get(attr: string): any;
+        getACL(): ACL;
+        has(attr: string): boolean;
+        hasChanged(attr: string): boolean;
+        increment(attr: string, amount?: number): any;
+        isValid(): boolean;
+        op(attr: string): any;
+        previous(attr: string): any;
+        previousAttributes(): any;
+        relation(attr: string): Relation;
+        remove(attr: string, item: any): any;
+        save<T>(options?: ParseDefaultOptions, arg2?: any, arg3?: any): Promise<T>;
+        saveAll<T>(list: Object[], options?: ParseDefaultOptions): Promise<T>;
+        set(key: string, value: any, options?: ParseDefaultOptions): boolean;
+        setACL(acl: ACL, options?: ParseDefaultOptions): boolean;
+        unset(attr: string, options?: any): any;
+        validate(attrs: any, options?: ParseDefaultOptions): boolean;
+
+    }
+
+    /**
+     * Every Parse application installed on a device registered for
+     * push notifications has an associated Installation object.
+     */
+    class Installation extends Object {
+
+        badge: any;
+        channels: string[];
+        timeZone: any;
+        deviceType: string;
+        pushType: string;
+        installationId: string;
+        deviceToken: string;
+        channelUris: string;
+        appName: string;
+        appVersion: string;
+        parseVersion: string;
+        appIdentifier: string;
+
+    }
+
+    /**
+     * Creates a new instance with the given models and options.  Typically, you
+     * will not call this method directly, but will instead make a subclass using
+     * <code>Parse.Collection.extend</code>.
+     *
+     * @param {Array} models An array of instances of <code>Parse.Object</code>.
+     *
+     * @param {Object} options An optional object with Backbone-style options.
+     * Valid options are:<ul>
+     *   <li>model: The Parse.Object subclass that this collection contains.
+     *   <li>query: An instance of Parse.Query to use when fetching items.
+     *   <li>comparator: A string property name or function to sort by.
+     * </ul>
+     *
+     * @see Parse.Collection.extend
+     *
+     * @class
+     *
+     * <p>Provides a standard collection class for our sets of models, ordered
+     * or unordered.  For more information, see the
+     * <a href="http://documentcloud.github.com/backbone/#Collection">Backbone
+     * documentation</a>.</p>
+     */
+    class Collection<T> extends Events implements IBaseObject {
+
+        model: Object;
+        models: Object[];
+        query: Query;
+        comparator: (object: Object) => any;
+
+        constructor(models?: Object[], options?: CollectionOptions);
+        static extend(instanceProps: any, classProps: any): any;
+
+        initialize(): void;
+        add(models: any[], options?: CollectionAddOptions);
+        at(index: number): Object;
+        chain(): _Chain<Collection<T>>;
+        fetch(options?: ParseDefaultOptions): Promise<T>;
+        create(model: Object, options?: ParseDefaultOptions): Object;
+        get(id: string): Object;
+        getByCid(cid: any): any;
+        pluck(attr: string): any[];
+        remove(model: any, options?: ParseDefaultOptions): Collection<T>;
+        remove(models: any[], options?: ParseDefaultOptions): Collection<T>;
+        reset(models: any[], options?: ParseDefaultOptions): Collection<T>;
+        sort(options?: ParseDefaultOptions): Collection<T>;
+        toJSON(): any;
+
+    }
+
+    /**
+     * @class
+     *
+     * <p>Parse.Events is a fork of Backbone's Events module, provided for your
+     * convenience.</p>
+     *
+     * <p>A module that can be mixed in to any object in order to provide
+     * it with custom events. You may bind callback functions to an event
+     * with `on`, or remove these functions with `off`.
+     * Triggering an event fires all callbacks in the order that `on` was
+     * called.
+     *
+     * <pre>
+     *     var object = {};
+     *     _.extend(object, Parse.Events);
+     *     object.on('expand', function(){ alert('expanded'); });
+     *     object.trigger('expand');</pre></p>
+     *
+     * <p>For more information, see the
+     * <a href="http://documentcloud.github.com/backbone/#Events">Backbone
+     * documentation</a>.</p>
+     */
+    class Events {
+
+        static off(events: string[], callback?: Function, context?: any);
+        static on(events: string[], callback?: Function, context?: any);
+        static trigger(events: string[]);
+        static bind();
+        static unbind();
+
+        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;
+
+    }
+
+    /**
+     * Creates a new parse Parse.Query for the given Parse.Object subclass.
+     * @param objectClass -
+     *   An instance of a subclass of Parse.Object, or a Parse className string.
+     * @class
+     *
+     * <p>Parse.Query defines a query that is used to fetch Parse.Objects. The
+     * most common use case is finding all objects that match a query through the
+     * <code>find</code> method. For example, this sample code fetches all objects
+     * of class <code>MyClass</code>. It calls a different function depending on
+     * whether the fetch succeeded or not.
+     *
+     * <pre>
+     * var query = new Parse.Query(MyClass);
+     * query.find({
+     *   success: function(results) {
+     *     // results is an array of Parse.Object.
+     *   },
+     *
+     *   error: function(error) {
+     *     // error is an instance of Parse.Error.
+     *   }
+     * });</pre></p>
+     *
+     * <p>A Parse.Query can also be used to retrieve a single object whose id is
+     * known, through the get method. For example, this sample code fetches an
+     * object of class <code>MyClass</code> and id <code>myId</code>. It calls a
+     * different function depending on whether the fetch succeeded or not.
+     *
+     * <pre>
+     * var query = new Parse.Query(MyClass);
+     * query.get(myId, {
+     *   success: function(object) {
+     *     // object is an instance of Parse.Object.
+     *   },
+     *
+     *   error: function(object, error) {
+     *     // error is an instance of Parse.Error.
+     *   }
+     * });</pre></p>
+     *
+     * <p>A Parse.Query can also be used to count the number of objects that match
+     * the query without retrieving all of those objects. For example, this
+     * sample code counts the number of objects of the class <code>MyClass</code>
+     * <pre>
+     * var query = new Parse.Query(MyClass);
+     * query.count({
+     *   success: function(number) {
+     *     // There are number instances of MyClass.
+     *   },
+     *
+     *   error: function(error) {
+     *     // error is an instance of Parse.Error.
+     *   }
+     * });</pre></p>
+     */
+    class Query extends BaseObject {
+
+        objectClass: any;
+        className: string;
+
+        constructor(objectClass: any);
+
+        static or(...var_args: Query[]): Query;
+
+        addAscending(key: string): Query;
+        addAscending(key: string[]): Query;
+        addDescending(key: string): Query;
+        addDescending(key: string[]): Query;
+        ascending(key: string): Query;
+        ascending(key: string[]): Query;
+        collection(items?: Object[], options?: ParseDefaultOptions): Collection<Object>;
+        containedIn(key: string, values: any[]): Query;
+        contains(key: string, substring: string): Query;
+        containsAll(key: string, values: any[]): Query;
+        count<T>(options?: ParseDefaultOptions): Promise<T>;
+        descending(key: string): Query;
+        descending(key: string[]): Query;
+        doesNotExist(key: string): Query;
+        doesNotMatchKeyInQuery(key: string, queryKey: string, query: Query): Query;
+        doesNotMatchQuery(key: string, query: Query): Query;
+        each<T>(callback: Function, options?: ParseDefaultOptions): Promise<T>;
+        endsWith(key: string, suffix: string): Query;
+        equalTo(key: string, value: any): Query;
+        exists(key: string): Query;
+        find<T>(options?: ParseDefaultOptions): Promise<T>;
+        first<T>(options?: ParseDefaultOptions): Promise<T>;
+        get(objectId: string, options?: ParseDefaultOptions): Promise<any>;
+        greaterThan(key: string, value: any): Query;
+        greaterThanOrEqualTo(key: string, value: any): Query;
+        include(key: string): Query;
+        include(keys: string[]): Query;
+        lessThan(key: string, value: any): Query;
+        lessThanOrEqualTo(key: string, value: any): Query;
+        limit(n: number): Query;
+        matches(key: string, regex: RegExp, modifiers: any): Query;
+        matchesKeyInQuery(key: string, queryKey: string, query: Query): Query;
+        matchesQuery(key: string, query: Query): Query;
+        near(key: string, point: GeoPoint): Query;
+        notContainedIn(key: string, values: any[]): Query;
+        notEqualTo(key: string, value: any): Query;
+        select(...keys: string[]): Query;
+        skip(n: number): Query;
+        startsWith(key: string, prefix: string): Query;
+        withinGeoBox(key: string, southwest: GeoPoint, northeast: GeoPoint): Query;
+        withinKilometers(key: string, point: GeoPoint, maxDistance: number): Query;
+        withinMiles(key: string, point: GeoPoint, maxDistance: number): Query;
+        withinRadians(key: string, point: GeoPoint, maxDistance: number): Query;
+    }
+
+    /**
+     * Represents a Role on the Parse server. Roles represent groupings of
+     * Users for the purposes of granting permissions (e.g. specifying an ACL
+     * for an Object). Roles are specified by their sets of child users and
+     * child roles, all of which are granted any permissions that the parent
+     * role has.
+     *
+     * <p>Roles must have a name (which cannot be changed after creation of the
+     * role), and must specify an ACL.</p>
+     * @class
+     * A Parse.Role is a local representation of a role persisted to the Parse
+     * cloud.
+     */
+    class Role extends Object {
+
+        constructor(name: string, acl: ACL);
+
+        getRoles(): Relation;
+        getUsers(): Relation;
+        getName(): string;
+        setName(name: string, options?: ParseDefaultOptions);
+    }
+
+    /**
+     * Routers map faux-URLs to actions, and fire events when routes are
+     * matched. Creating a new one sets its `routes` hash, if not set statically.
+     * @class
+     *
+     * <p>A fork of Backbone.Router, provided for your convenience.
+     * For more information, see the
+     * <a href="http://documentcloud.github.com/backbone/#Router">Backbone
+     * documentation</a>.</p>
+     * <p><strong><em>Available in the client SDK only.</em></strong></p>
+     */
+    class Router extends Events {
+
+        routes: any[];
+
+        constructor(options?: RouterOptions);
+
+        static extend(instanceProps: any, classProps: any): any;
+
+        initialize(): void;
+        navigate(fragment: string, options?: NavigateOptions): Router;
+        navigate(fragment: string, trigger?: boolean): Router;
+        route(route: string, name: string, callback: Function): Router;
+    }
+
+    /**
+     * @class
+     *
+     * <p>A Parse.User object is a local representation of a user persisted to the
+     * Parse cloud. This class is a subclass of a Parse.Object, and retains the
+     * same functionality of a Parse.Object, but also extends it with various
+     * user specific methods, like authentication, signing up, and validation of
+     * uniqueness.</p>
+     */
+    class User extends Object {
+
+        static current(): User;
+        static signUp<T>(username: string, password: string, attrs: any, options?: ParseDefaultOptions): Promise<T>;
+        static logIn<T>(username: string, password: string, options?: ParseDefaultOptions): Promise<T>;
+        static logOut(): void;
+        static allowCustomUserClass(isAllowed: boolean): void;
+        static become<T>(sessionToken: string, options?: ParseDefaultOptions): Promise<T>;
+        static requestPasswordReset<T>(email: string, options?: ParseDefaultOptions): Promise<T>;
+
+        signUp<T>(attrs: any, options?: ParseDefaultOptions): Promise<T>;
+        logIn<T>(options?: ParseDefaultOptions): Promise<T>;
+        fetch<T>(options?: ParseDefaultOptions): Promise<T>;
+        save<T>(arg1: any, arg2: any, arg3: any): Promise<T>;
+        authenticated(): boolean;
+        isCurrent(): boolean;
+
+        getEmail(): string;
+        setEmail(email: string, options: ParseDefaultOptions): boolean;
+
+        getUsername(): string;
+        setUsername(username: string, options?: ParseDefaultOptions): boolean;
+
+        setPassword(password: string, options?: ParseDefaultOptions): boolean;
+
+        getSessionToken(): string;
+    }
+
+    /**
+     * Creating a Parse.View creates its initial element outside of the DOM,
+     * if an existing element is not provided...
+     * @class
+     *
+     * <p>A fork of Backbone.View, provided for your convenience.  If you use this
+     * class, you must also include jQuery, or another library that provides a
+     * jQuery-compatible $ function.  For more information, see the
+     * <a href="http://documentcloud.github.com/backbone/#View">Backbone
+     * documentation</a>.</p>
+     * <p><strong><em>Available in the client SDK only.</em></strong></p>
+     */
+    class View<T> extends Events {
+
+        model: any;
+        collection: any;
+        id: string;
+        cid: string;
+        className: string;
+        tagName: string;
+        el: any;
+        $el: JQuery;
+        attributes: any;
+
+        constructor(options?: ViewOptions);
+
+        static extend(properties: any, classProperties?: any): any;
+
+        $(selector?: string): JQuery;
+        setElement(element: HTMLElement, delegate?: boolean): View<T>;
+        setElement(element: JQuery, delegate?: boolean): View<T>;
+        render(): View<T>;
+        remove(): View<T>;
+        make(tagName: any, attributes?: any, content?: any): any;
+        delegateEvents(events?: any): any;
+        undelegateEvents(): any;
+
+    }
+
+    module Analytics {
+
+        function track<T>(name: string, dimensions: any):Promise<T>;
+    }
+
+    /**
+     * Provides a set of utilities for using Parse with Facebook.
+     * @namespace
+     * Provides a set of utilities for using Parse with Facebook.
+     */
+    module FacebookUtils {
+
+        function init(options?: any);
+        function isLinked(user: User): boolean;
+        function link(user: User, permissions: any, options?: ParseDefaultOptions): void;
+        function logIn(permissions: any, options?: ParseDefaultOptions): void;
+        function unlink(user: User, options?: ParseDefaultOptions): void;
+    }
+
+    /**
+     * @namespace Contains functions for calling and declaring
+     * <a href="/docs/cloud_code_guide#functions">cloud functions</a>.
+     * <p><strong><em>
+     *   Some functions are only available from Cloud Code.
+     * </em></strong></p>
+     */
+    module Cloud {
+
+        interface CookieOptions {
+            domain?: string;
+            expires?: Date;
+            httpOnly?: boolean;
+            maxAge?: number;
+            path?: string;
+            secure?: boolean;
+        }
+
+        interface HttpResponse {
+            buffer?: Buffer;
+            cookies?: any;
+            data?: any;
+            headers?: any;
+            status?: number;
+            text?: string;
+        }
+
+        interface JobRequest {
+            params: any;
+        }
+
+        interface JobStatus {
+            error?: Function;
+            message?: Function;
+            success?: Function;
+        }
+
+        interface FunctionRequest {
+            installationId?: String;
+            master?: boolean;
+            params?: any;
+            user?: User;
+        }
+
+        interface FunctionResponse {
+            success?: (response: HttpResponse) => void;
+            error?: (response: HttpResponse) => void;
+        }
+
+        interface Cookie {
+            name?: string;
+            options?: CookieOptions;
+            value?: string;
+        }
+
+        interface AfterSaveRequest extends FunctionRequest {}
+        interface AfterDeleteRequest extends FunctionRequest {}
+        interface BeforeDeleteRequest extends FunctionRequest {}
+        interface BeforeDeleteResponse extends FunctionResponse {}
+        interface BeforeSaveRequest extends FunctionRequest {}
+        interface BeforeSaveResponse extends FunctionResponse {}
+
+        function afterDelete(arg1: any, func?: (request: AfterDeleteRequest) => void): void;
+        function afterSave(arg1: any, func?: (request: AfterSaveRequest) => void): void;
+        function beforeDelete(arg1: any, func?: (request: BeforeDeleteRequest, response: BeforeDeleteResponse) => void): void;
+        function beforeSave(arg1: any, func?: (request: BeforeSaveRequest, response: BeforeSaveResponse) => void): void;
+        function define(name: string, func?: (request: FunctionRequest, response: FunctionResponse) => void): void;
+        function httpRequest<T>(options: ParseDefaultOptions): Promise<HttpResponse>;
+        function job(name: string, func?: (request: JobRequest, status: JobStatus) => void): HttpResponse;
+        function run<T>(name: string, data?: any, options?: ParseDefaultOptions): Promise<T>;
+        function useMasterKey(): void;
+    }
+
+
+    class Error {
+
+        code: ErrorCode;
+        message: string;
+
+        constructor(code: ErrorCode, message: string);
+
+    }
+
+    enum ErrorCode {
+
+        OTHER_CAUSE = -1,
+        INTERNAL_SERVER_ERROR = 1,
+        CONNECTION_FAILED =  100,
+        OBJECT_NOT_FOUND =  101,
+        INVALID_QUERY =  102,
+        INVALID_CLASS_NAME =  103,
+        MISSING_OBJECT_ID =  104,
+        INVALID_KEY_NAME =  105,
+        INVALID_POINTER =  106,
+        INVALID_JSON =  107,
+        COMMAND_UNAVAILABLE =  108,
+        NOT_INITIALIZED =  109,
+        INCORRECT_TYPE =  111,
+        INVALID_CHANNEL_NAME =  112,
+        PUSH_MISCONFIGURED =  115,
+        OBJECT_TOO_LARGE =  116,
+        OPERATION_FORBIDDEN =  119,
+        CACHE_MISS =  120,
+        INVALID_NESTED_KEY =  121,
+        INVALID_FILE_NAME =  122,
+        INVALID_ACL =  123,
+        TIMEOUT =  124,
+        INVALID_EMAIL_ADDRESS =  125,
+        MISSING_CONTENT_TYPE =  126,
+        MISSING_CONTENT_LENGTH =  127,
+        INVALID_CONTENT_LENGTH =  128,
+        FILE_TOO_LARGE =  129,
+        FILE_SAVE_ERROR =  130,
+        FILE_DELETE_ERROR =  153,
+        DUPLICATE_VALUE =  137,
+        INVALID_ROLE_NAME =  139,
+        EXCEEDED_QUOTA =  140,
+        SCRIPT_FAILED =  141,
+        VALIDATION_ERROR =  142,
+        INVALID_IMAGE_DATA =  150,
+        UNSAVED_FILE_ERROR =  151,
+        INVALID_PUSH_TIME_ERROR = 152,
+        USERNAME_MISSING =  200,
+        PASSWORD_MISSING =  201,
+        USERNAME_TAKEN =  202,
+        EMAIL_TAKEN =  203,
+        EMAIL_MISSING =  204,
+        EMAIL_NOT_FOUND =  205,
+        SESSION_MISSING =  206,
+        MUST_CREATE_USER_THROUGH_SIGNUP =  207,
+        ACCOUNT_ALREADY_LINKED =  208,
+        LINKED_ID_MISSING =  250,
+        INVALID_LINKED_SESSION =  251,
+        UNSUPPORTED_SERVICE =  252,
+        AGGREGATE_ERROR = 600,
+        FILE_READ_ERROR = 601,
+        X_DOMAIN_REQUEST = 602
+    }
+
+    /**
+     * @class
+     * A Parse.Op is an atomic operation that can be applied to a field in a
+     * Parse.Object. For example, calling <code>object.set("foo", "bar")</code>
+     * is an example of a Parse.Op.Set. Calling <code>object.unset("foo")</code>
+     * is a Parse.Op.Unset. These operations are stored in a Parse.Object and
+     * sent to the server as part of <code>object.save()</code> operations.
+     * Instances of Parse.Op should be immutable.
+     *
+     * You should not create subclasses of Parse.Op or instantiate Parse.Op
+     * directly.
+     */
+    module Op {
+
+        interface BaseOperation extends IBaseObject {
+            objects(): any[];
+        }
+
+        interface Add extends BaseOperation {
+        }
+
+        interface AddUnique extends BaseOperation {
+        }
+
+        interface Increment extends IBaseObject {
+            amount: number;
+        }
+
+        interface Relation extends IBaseObject {
+            added(): Object[];
+            removed: Object[];
+        }
+
+        interface Set extends IBaseObject {
+            value(): any;
+        }
+
+        interface Unset extends IBaseObject {
+        }
+
+    }
+
+    /**
+     * Contains functions to deal with Push in Parse
+     * @name Parse.Push
+     * @namespace
+     */
+    module Push {
+
+        function send<T>(data: PushData, options?: ParseDefaultOptions):Promise<T>;
+    }
+
+    /**
+     * Call this method first to set up your authentication tokens for Parse.
+     * You can get your keys from the Data Browser on parse.com.
+     * @param {String} applicationId Your Parse Application ID.
+     * @param {String} javaScriptKey Your Parse JavaScript Key.
+     * @param {String} masterKey (optional) Your Parse Master Key. (Node.js only!)
+     */
+    function initialize(applicationId: string, javaScriptKey: string, masterKey?: string);
+
+}
+
+declare module "parse" {
+    var type: typeof Parse;
+    var subType: {
+        Parse: typeof type;
+    }
+
+    export = subType;
+}