// Type definitions for parse v1.9.2 // Project: https://parse.com/ // Definitions by: Ullisen Media Group , David Poetzsch-Heffter // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare namespace Parse { var applicationId: string; var javaScriptKey: string | undefined; var masterKey: string | undefined; var serverURL: string; var VERSION: string; interface SuccessOption { success?: Function; } interface ErrorOption { error?: Function; } interface SuccessFailureOptions extends SuccessOption, ErrorOption { } interface SessionTokenOption { sessionToken?: string; } interface WaitOption { /** * Set to true to wait for the server to confirm success * before triggering an event. */ wait?: boolean; } interface UseMasterKeyOption { /** * In Cloud Code and Node only, causes the Master Key to be used for this request. */ useMasterKey?: boolean; } interface ScopeOptions extends SessionTokenOption, UseMasterKeyOption { } interface SilentOption { /** * Set to true to avoid firing the event. */ silent?: boolean; } /** * A Promise is returned by async methods as a hook to provide callbacks to be * called when the async task is fulfilled. * *

Typical usage would be like:

     *    query.find().then(function(results) {
     *      results[0].set("foo", "bar");
     *      return results[0].saveAsync();
     *    }).then(function(result) {
     *      console.log("Updated " + result.id);
     *    });
     *

* * @see Parse.Promise.prototype.then * @class */ interface IPromise { then(resolvedCallback: (...values: T[]) => IPromise, rejectedCallback?: (reason: any) => IPromise): IPromise; then(resolvedCallback: (...values: T[]) => U, rejectedCallback?: (reason: any) => IPromise): IPromise; then(resolvedCallback: (...values: T[]) => U, rejectedCallback?: (reason: any) => U): IPromise; } class Promise implements IPromise { static as(resolvedValue: U): Promise; static error(error: any): Promise; static is(possiblePromise: any): Boolean; static when(promises: IPromise[]): Promise; static when(...promises: IPromise[]): Promise; always(callback: Function): Promise; done(callback: Function): Promise; fail(callback: Function): Promise; reject(error: any): void; resolve(result: any): void; then(resolvedCallback: (...values: T[]) => IPromise, rejectedCallback?: (reason: any) => IPromise): IPromise; then(resolvedCallback: (...values: T[]) => U, rejectedCallback?: (reason: any) => IPromise): IPromise; then(resolvedCallback: (...values: T[]) => U, rejectedCallback?: (reason: any) => U): IPromise; } 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 * *

An ACL, or Access Control List can be added to any * Parse.Object to restrict access to only a subset of users * of your application.

*/ class ACL extends BaseObject { permissionsById: any; constructor(arg1?: any); setPublicReadAccess(allowed: boolean): void; getPublicReadAccess(): boolean; setPublicWriteAccess(allowed: boolean): void; getPublicWriteAccess(): boolean; setReadAccess(userId: User, allowed: boolean): void; getReadAccess(userId: User): boolean; setReadAccess(userId: string, allowed: boolean): void; getReadAccess(userId: string): boolean; setRoleReadAccess(role: Role, allowed: boolean): void; setRoleReadAccess(role: string, allowed: boolean): void; getRoleReadAccess(role: Role): boolean; getRoleReadAccess(role: string): boolean; setRoleWriteAccess(role: Role, allowed: boolean): void; setRoleWriteAccess(role: string, allowed: boolean): void; getRoleWriteAccess(role: Role): boolean; getRoleWriteAccess(role: string): boolean; setWriteAccess(userId: User, allowed: boolean): void; setWriteAccess(userId: string, allowed: boolean): void; 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:
     * 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.
     *   });
     * }
* @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?: SuccessFailureOptions): Promise; } /** * Creates a new GeoPoint with any of the following forms:
* 
     *   new GeoPoint(otherGeoPoint)
     *   new GeoPoint(30, 30)
     *   new GeoPoint([30, 30])
     *   new GeoPoint({latitude: 30, longitude: 30})
     *   new GeoPoint()  // defaults to (0, 0)
     *
* @class * *

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.

* *

Only one key in a class may contain a GeoPoint.

* *

Example:

     *   var point = new Parse.GeoPoint(30.0, -20.0);
     *   var object = new Parse.Object("PlaceObject");
     *   object.set("location", point);
     *   object.save();

*/ class GeoPoint extends BaseObject { latitude: number; longitude: number; constructor(arg1?: any, arg2?: any); current(options?: SuccessFailureOptions): 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 Parse.history * that will be created for you automatically if you make use of * Routers with routes. * @class * *

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 * Backbone documentation.

*

Available in the client SDK only.

*/ 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. * *

You won't normally call this method directly. It is recommended that * you use a subclass of Parse.Object instead, created by calling * extend.

* *

However, if you don't want to use a subclass, or aren't sure which * subclass is appropriate, you can use this form:

     *     var object = new Parse.Object("ClassName");
     *
* That is basically equivalent to:
     *     var MyClass = Parse.Object.extend("ClassName");
     *     var object = new MyClass();
     *

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

The fundamental unit of Parse data, which implements the Backbone Model * interface.

*/ class Object extends BaseObject { id: string; createdAt: Date; updatedAt: Date; 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(list: T[], options: SuccessFailureOptions): Promise; static fetchAllIfNeeded(list: T[], options: SuccessFailureOptions): Promise; static destroyAll(list: T[], options?: Object.DestroyAllOptions): Promise; static saveAll(list: T[], options?: Object.SaveAllOptions): Promise; static registerSubclass(className: string, clazz: new (options?: any) => T): void; initialize(): void; add(attr: string, item: any): this; addUnique(attr: string, item: any): any; change(options: any): this; changedAttributes(diff: any): boolean; clear(options: any): any; clone(): this; destroy(options?: Object.DestroyOptions): Promise; dirty(attr: String): boolean; dirtyKeys(): string[]; escape(attr: string): string; existed(): boolean; fetch(options?: Object.FetchOptions): Promise; get(attr: string): any | undefined; getACL(): ACL | undefined; 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(attrs?: { [key: string]: any } | null, options?: Object.SaveOptions): Promise; save(key: string, value: any, options?: Object.SaveOptions): Promise; set(key: string, value: any, options?: Object.SetOptions): boolean; setACL(acl: ACL, options?: SuccessFailureOptions): boolean; unset(attr: string, options?: any): any; validate(attrs: any, options?: SuccessFailureOptions): boolean; } namespace Object { interface DestroyOptions extends SuccessFailureOptions, WaitOption, ScopeOptions { } interface DestroyAllOptions extends SuccessFailureOptions, ScopeOptions { } interface FetchOptions extends SuccessFailureOptions, ScopeOptions { } interface SaveOptions extends SuccessFailureOptions, SilentOption, ScopeOptions, WaitOption { } interface SaveAllOptions extends SuccessFailureOptions, ScopeOptions { } interface SetOptions extends ErrorOption, SilentOption { promise?: any; } } /** * 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 * Parse.Collection.extend. * * @param {Array} models An array of instances of Parse.Object. * * @param {Object} options An optional object with Backbone-style options. * Valid options are:
    *
  • model: The Parse.Object subclass that this collection contains. *
  • query: An instance of Parse.Query to use when fetching items. *
  • comparator: A string property name or function to sort by. *
* * @see Parse.Collection.extend * * @class * *

Provides a standard collection class for our sets of models, ordered * or unordered. For more information, see the * Backbone * documentation.

*/ class Collection extends Events implements IBaseObject { model: Object; models: Object[]; query: Query; comparator: (object: Object) => any; constructor(models?: Object[], options?: Collection.Options); static extend(instanceProps: any, classProps: any): any; initialize(): void; add(models: any[], options?: Collection.AddOptions): Collection; at(index: number): Object; //chain(): _._Chain>; fetch(options?: Collection.FetchOptions): Promise; create(model: Object, options?: Collection.CreateOptions): Object; get(id: string): Object; getByCid(cid: any): any; pluck(attr: string): any[]; remove(model: any, options?: Collection.RemoveOptions): Collection; remove(models: any[], options?: Collection.RemoveOptions): Collection; reset(models: any[], options?: Collection.ResetOptions): Collection; sort(options?: Collection.SortOptions): Collection; toJSON(): any; } namespace Collection { interface Options { model?: Object; query?: Query; comparator?: string; } interface AddOptions extends SilentOption { /** * The index at which to add the models. */ at?: number; } interface CreateOptions extends SuccessFailureOptions, WaitOption, SilentOption, ScopeOptions { } interface FetchOptions extends SuccessFailureOptions, SilentOption, ScopeOptions { } interface RemoveOptions extends SilentOption { } interface ResetOptions extends SilentOption { } interface SortOptions extends SilentOption { } } /** * @class * *

Parse.Events is a fork of Backbone's Events module, provided for your * convenience.

* *

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

     *     var object = {};
     *     _.extend(object, Parse.Events);
     *     object.on('expand', function(){ alert('expanded'); });
     *     object.trigger('expand');

* *

For more information, see the * Backbone * documentation.

*/ class Events { static off(events: string[], callback?: Function, context?: any): Events; static on(events: string[], callback?: Function, context?: any): Events; static trigger(events: string[]): Events; static bind(): Events; static unbind(): Events; on(eventName: string, callback?: Function, context?: any): Events; off(eventName?: string | null, callback?: Function | null, context?: any): Events; trigger(eventName: string, ...args: any[]): Events; bind(eventName: string, callback: Function, context?: any): Events; unbind(eventName?: string, callback?: Function, context?: any): Events; } /** * 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 * *

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 * find method. For example, this sample code fetches all objects * of class MyClass. It calls a different function depending on * whether the fetch succeeded or not. * * 

     * 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.
     *   }
     * });

* *

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 MyClass and id myId. It calls a * different function depending on whether the fetch succeeded or not. * * 

     * 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.
     *   }
     * });

* *

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 MyClass * 

     * 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.
     *   }
     * });

*/ class Query extends BaseObject { objectClass: any; className: string; constructor(objectClass: string); constructor(objectClass: new (...args: any[]) => Object); 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?: Collection.Options): Collection; containedIn(key: string, values: any[]): Query; contains(key: string, substring: string): Query; containsAll(key: string, values: any[]): Query; count(options?: Query.CountOptions): Promise; 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(callback: Function, options?: Query.EachOptions): Promise; endsWith(key: string, suffix: string): Query; equalTo(key: string, value: any): Query; exists(key: string): Query; find(options?: Query.FindOptions): Promise; first(options?: Query.FirstOptions): Promise; get(objectId: string, options?: Query.GetOptions): Promise; 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; } namespace Query { interface EachOptions extends SuccessFailureOptions, ScopeOptions { } interface CountOptions extends SuccessFailureOptions, ScopeOptions { } interface FindOptions extends SuccessFailureOptions, ScopeOptions { } interface FirstOptions extends SuccessFailureOptions, ScopeOptions { } interface GetOptions extends SuccessFailureOptions, ScopeOptions { } } /** * 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. * *

Roles must have a name (which cannot be changed after creation of the * role), and must specify an ACL.

* @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?: SuccessFailureOptions): any; } class Config extends Object { static get(options?: SuccessFailureOptions): Promise; static current(): Config; get(attr: string): any; escape(attr: string): any; } class Session extends Object { static current(): Promise; getSessionToken(): string; isCurrentSessionRevocable(): boolean; } /** * 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 * *

A fork of Backbone.Router, provided for your convenience. * For more information, see the * Backbone * documentation.

*

Available in the client SDK only.

*/ class Router extends Events { routes: Router.RouteMap; constructor(options?: Router.Options); static extend(instanceProps: any, classProps: any): any; initialize(): void; navigate(fragment: string, options?: Router.NavigateOptions): Router; navigate(fragment: string, trigger?: boolean): Router; route(route: string, name: string, callback: Function): Router; } namespace Router { interface Options { routes: RouteMap; } interface RouteMap { [url: string]: string; } interface NavigateOptions { trigger?: boolean; } } /** * @class * *

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.

*/ class User extends Object { static current(): User | undefined; static signUp(username: string, password: string, attrs: any, options?: SuccessFailureOptions): Promise; static logIn(username: string, password: string, options?: SuccessFailureOptions): Promise; static logOut(): Promise; static allowCustomUserClass(isAllowed: boolean): void; static become(sessionToken: string, options?: SuccessFailureOptions): Promise; static requestPasswordReset(email: string, options?: SuccessFailureOptions): Promise; static extend(protoProps?: any, classProps?: any): any; signUp(attrs: any, options?: SuccessFailureOptions): Promise; logIn(options?: SuccessFailureOptions): Promise; authenticated(): boolean; isCurrent(): boolean; getEmail(): string | undefined; setEmail(email: string, options?: SuccessFailureOptions): boolean; getUsername(): string | undefined; setUsername(username: string, options?: SuccessFailureOptions): boolean; setPassword(password: string, options?: SuccessFailureOptions): boolean; getSessionToken(): string; } /** * Creating a Parse.View creates its initial element outside of the DOM, * if an existing element is not provided... * @class * *

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 * Backbone * documentation.

*

Available in the client SDK only.

*/ class View extends Events { model: any; collection: any; id: string; cid: string; className: string; tagName: string; el: any; //$el: JQuery; attributes: any; constructor(options?: View.Options); static extend(properties: any, classProperties?: any): any; //$(selector?: string): JQuery; setElement(element: HTMLElement, delegate?: boolean): View; //setElement(element: JQuery, delegate?: boolean): View; render(): View; remove(): View; make(tagName: any, attributes?: View.Attribute[], content?: any): any; delegateEvents(events?: any): any; undelegateEvents(): any; } namespace View { interface Options { model?: any; collection?: any; el?: any; id?: string; className?: string; tagName?: string; attributes?: Attribute[]; } interface Attribute { [attributeName: string]: string | number | boolean; } } namespace Analytics { function track(name: string, dimensions: any): Promise; } /** * Provides a set of utilities for using Parse with Facebook. * @namespace * Provides a set of utilities for using Parse with Facebook. */ namespace FacebookUtils { function init(options?: any): void; function isLinked(user: User): boolean; function link(user: User, permissions: any, options?: SuccessFailureOptions): void; function logIn(permissions: any, options?: SuccessFailureOptions): void; function unlink(user: User, options?: SuccessFailureOptions): void; } /** * @namespace Contains functions for calling and declaring * cloud functions. *

* Some functions are only available from Cloud Code. *

*/ namespace 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?: (response: any) => void; message?: (response: any) => void; success?: (response: any) => void; } interface FunctionRequest { installationId?: String; master?: boolean; params?: any; user?: User; } interface FunctionResponse { success: (response: any) => void; error: (response: any) => void; } interface Cookie { name?: string; options?: CookieOptions; value?: string; } interface SaveRequest extends FunctionRequest { object: Object; } interface AfterSaveRequest extends SaveRequest { } interface AfterDeleteRequest extends FunctionRequest { } interface BeforeDeleteRequest extends FunctionRequest { } interface BeforeDeleteResponse extends FunctionResponse { } interface BeforeSaveRequest extends SaveRequest { } interface BeforeSaveResponse extends FunctionResponse { success: () => void; } 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(options: HTTPOptions): Promise; function job(name: string, func?: (request: JobRequest, status: JobStatus) => void): HttpResponse; function run(name: string, data?: any, options?: RunOptions): Promise; function useMasterKey(): void; interface RunOptions extends SuccessFailureOptions, ScopeOptions { } /** * To use this Cloud Module in Cloud Code, you must require 'buffer' in your JavaScript file. * * import Buffer = require("buffer").Buffer; */ var HTTPOptions: new () => HTTPOptions; interface HTTPOptions { /** * The body of the request. * If it is a JSON object, then the Content-Type set in the headers must be application/x-www-form-urlencoded or application/json. * You can also set this to a Buffer object to send raw bytes. * If you use a Buffer, you should also set the Content-Type header explicitly to describe what these bytes represent. */ //body?: string | Buffer | Object; body?: string | Object; /** * Defaults to 'false'. */ followRedirects?: boolean; /** * The headers for the request. */ headers?: { [headerName: string]: string | number | boolean; }; /** *The method of the request (i.e GET, POST, etc). */ method?: string; /** * The query portion of the url. */ params?: any; /** * The url to send the request to. */ url: string; success?: (response: any) => void; error?: (response: any) => void; } } class Error { code: ErrorCode; message: string; constructor(code: ErrorCode, message: string); } /* * We need to inline the codes in order to make compilation work without this type definition as dependency. */ const 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, 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, FILE_DELETE_ERROR = 153, REQUEST_LIMIT_EXCEEDED = 155, INVALID_EVENT_NAME = 160, 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, INVALID_SESSION_TOKEN = 209, 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 object.set("foo", "bar") * is an example of a Parse.Op.Set. Calling object.unset("foo") * is a Parse.Op.Unset. These operations are stored in a Parse.Object and * sent to the server as part of object.save() operations. * Instances of Parse.Op should be immutable. * * You should not create subclasses of Parse.Op or instantiate Parse.Op * directly. */ namespace 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 */ namespace Push { function send(data: PushData, options?: SendOptions): Promise; 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; } interface SendOptions extends UseMasterKeyOption { success?: () => void; error?: (error: Error) => void; } } /** * 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 (optional) Your Parse JavaScript Key (Not needed for parse-server) * @param {String} masterKey (optional) Your Parse Master Key. (Node.js only!) */ function initialize(applicationId: string, javaScriptKey?: string, masterKey?: string): void; } declare module "parse/node" { export = Parse; } declare module "parse" { import * as parse from "parse/node"; export = parse }