;
new (): Installation;
}
const Installation: InstallationConstructor;
/**
* Creates a new Moralis.Query for the given Moralis.Object subclass.
* @param objectClass -
* An instance of a subclass of Moralis.Object, or a Moralis className string.
*
* Moralis.Query defines a query that is used to fetch Moralis.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 Moralis.Query(MyClass);
* query.find({
* success: function(results) {
* // results is an array of Moralis.Object.
* },
*
* error: function(error) {
* // error is an instance of Moralis.Error.
* }
* });
*
* A Moralis.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 Moralis.Query(MyClass);
* query.get(myId, {
* success: function(object) {
* // object is an instance of Moralis.Object.
* },
*
* error: function(object, error) {
* // error is an instance of Moralis.Error.
* }
* });
*
* A Moralis.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 Moralis.Query(MyClass);
* query.count({
* success: function(number) {
* // There are number instances of MyClass.
* },
*
* error: function(error) {
* // error is an instance of Moralis.Error.
* }
* });
*/
class Query {
objectClass: any;
className: string;
constructor(objectClass: string | (new (...args: any[]) => T | Object));
static and(...args: Array>): Query;
static fromJSON(className: string | (new () => U), json: any): Query;
static nor(...args: Array>): Query;
static or(...var_args: Array>): Query;
addAscending(key: K | K[]): this;
addDescending(key: K | K[]): this;
ascending(key: K | K[]): this;
aggregate(pipeline: Query.AggregationOptions | Query.AggregationOptions[]): Promise;
containedBy(
key: K,
values: Array
): this;
containedIn(
key: K,
values: Array
): this;
contains(
key: K,
substring: string
): this;
containsAll(
key: K,
values: any[]
): this;
containsAllStartingWith(
key: K,
values: any[]
): this;
count(options?: Query.CountOptions): Promise;
descending(key: K | K[]): this;
doesNotExist(key: K): this;
doesNotMatchKeyInQuery<
U extends Object,
K extends keyof T['attributes'] | keyof BaseAttributes,
X extends Extract
>(key: K, queryKey: X, query: Query): this;
doesNotMatchQuery(
key: K,
query: Query
): this;
distinct(key: K): Promise;
eachBatch(
callback: (objs: T[]) => PromiseLike | void,
options?: Query.BatchOptions
): Promise;
each(
callback: (obj: T) => PromiseLike | void,
options?: Query.BatchOptions
): Promise;
hint(value: string | object): this;
explain(explain: boolean): this;
map(
callback: (currentObject: T, index: number, query: Query) => PromiseLike | U,
options?: Query.BatchOptions
): Promise;
reduce(
callback: (accumulator: T, currentObject: T, index: number) => PromiseLike | T,
initialValue?: undefined,
options?: Query.BatchOptions
): Promise;
reduce(
callback: (accumulator: U, currentObject: T, index: number) => PromiseLike | U,
initialValue: U,
options?: Query.BatchOptions
): Promise;
filter(
callback: (currentObject: T, index: number, query: Query) => PromiseLike | boolean,
options?: Query.BatchOptions
): Promise;
endsWith(key: K, suffix: string): this;
equalTo(
key: K,
value:
| T['attributes'][K]
| (T['attributes'][K] extends Object
? Pointer
: T['attributes'][K] extends Array
? E
: never)
): this;
exclude(...keys: K[]): this;
exists(key: K): this;
find(options?: Query.FindOptions): Promise;
first(options?: Query.FirstOptions): Promise;
fromNetwork(): this;
fromLocalDatastore(): this;
fromPin(): this;
fromPinWithName(name: string): this;
cancel(): this;
fullText(
key: K,
value: string,
options?: Query.FullTextOptions
): this;
get(objectId: string, options?: Query.GetOptions): Promise;
greaterThan(
key: K,
value: T['attributes'][K]
): this;
greaterThanOrEqualTo(
key: K,
value: T['attributes'][K]
): this;
include(...key: K[]): this;
include(key: K[]): this;
includeAll(): Query;
lessThan(
key: K,
value: T['attributes'][K]
): this;
lessThanOrEqualTo(
key: K,
value: T['attributes'][K]
): this;
limit(n: number): Query;
matches(
key: K,
regex: RegExp,
modifiers?: string
): this;
matchesKeyInQuery<
U extends Object,
K extends keyof T['attributes'],
X extends Extract
>(key: K, queryKey: X, query: Query): this;
matchesQuery(key: K, query: Query): this;
near(key: K, point: GeoPoint): this;
notContainedIn(
key: K,
values: Array
): this;
notEqualTo(
key: K,
value:
| T['attributes'][K]
| (T['attributes'][K] extends Object
? Pointer
: T['attributes'][K] extends Array
? E
: never)
): this;
polygonContains(
key: K,
point: GeoPoint
): this;
select(...keys: K[]): this;
select(keys: K[]): this;
skip(n: number): Query;
sortByTextScore(): this;
startsWith(
key: K,
prefix: string
): this;
subscribe(): Promise;
toJSON(): any;
withJSON(json: any): this;
withCount(includeCount?: boolean): this;
withinGeoBox(
key: K,
southwest: GeoPoint,
northeast: GeoPoint
): this;
withinKilometers(
key: K,
point: GeoPoint,
maxDistance: number,
sorted?: boolean
): this;
withinMiles(
key: K,
point: GeoPoint,
maxDistance: number,
sorted?: boolean
): this;
withinPolygon(
key: K,
points: number[][]
): this;
withinRadians(
key: K,
point: GeoPoint,
maxDistance: number
): this;
}
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 {}
// According to http://docs.moralis.io/rest/guide/#aggregate-queries
interface AggregationOptions {
group?: { objectId?: string; [key: string]: any };
match?: { [key: string]: any };
project?: { [key: string]: any };
limit?: number;
skip?: number;
// Sort documentation https://docs.mongodb.com/v3.2/reference/operator/aggregation/sort/#pipe._S_sort
sort?: { [key: string]: 1 | -1 };
// Sample documentation: https://docs.mongodb.com/v3.2/reference/operator/aggregation/sample/
sample?: { size: number };
}
// According to https://docs.moralis.io/Moralis-SDK-JS/api/2.1.0/Moralis.Query.html#fullText
interface FullTextOptions {
language?: string;
caseSensitive?: boolean;
diacriticSensitive?: boolean;
}
interface BatchOptions extends FullOptions {
batchSize?: number;
}
}
/**
* Represents a LiveQuery Subscription.
*
* @see https://docs.moralis.io/js/guide/#live-queries
* @see NodeJS.EventEmitter
*
* Events list
* ---
* `open` - when you call `query.subscribe()`, we send a subscribe request to
* the LiveQuery server, when we get the confirmation from the LiveQuery server,
* this event will be emitted. When the client loses WebSocket connection to the
* LiveQuery server, we will try to auto reconnect the LiveQuery server. If we
* reconnect the LiveQuery server and successfully resubscribe the MoralisQuery,
* you'll also get this event.
*
* ```
* subscription.on('open', () => {});
* ```
* ---
* `create` - when a new MoralisObject is created and it fulfills the MoralisQuery you subscribe,
* you'll get this event. The object is the MoralisObject which is created.
*
* ```
* subscription.on('create', (object: Moralis.Object) => {});
* ```
* ---
* `update` event - when an existing MoralisObject which fulfills the MoralisQuery you subscribe
* is updated (The MoralisObject fulfills the MoralisQuery before and after changes),
* you'll get this event. The object is the MoralisObject which is updated.
* Its content is the latest value of the MoralisObject.
*
* ```
* subscription.on('update', (object: Moralis.Object) => {});
* ```
* ---
* `enter` event - when an existing MoralisObject's old value doesn't fulfill the MoralisQuery
* but its new value fulfills the MoralisQuery, you'll get this event. The object is the
* MoralisObject which enters the MoralisQuery. Its content is the latest value of the MoralisObject.
*
* ```
* subscription.on('enter', (object: Moralis.Object) => {});
* ```
* ---
* `update` event - when an existing MoralisObject's old value fulfills the MoralisQuery but its new value
* doesn't fulfill the MoralisQuery, you'll get this event. The object is the MoralisObject
* which leaves the MoralisQuery. Its content is the latest value of the MoralisObject.
*
* ```
* subscription.on('leave', (object: Moralis.Object) => {});
* ```
* ---
* `delete` event - when an existing MoralisObject which fulfills the MoralisQuery is deleted, you'll
* get this event. The object is the MoralisObject which is deleted.
*
* ```
* subscription.on('delete', (object: Moralis.Object) => {});
* ```
* ---
* `close` event - when the client loses the WebSocket connection to the LiveQuery
* server and we stop receiving events, you'll get this event.
*
* ```
* subscription.on('close', () => {});
* ```
*/
class LiveQuerySubscription extends EventEmitter {
/**
* Creates an instance of LiveQuerySubscription.
*
* @param id
* @param query
* @param [sessionToken]
*/
constructor(id: string, query: string, sessionToken?: string);
on(
event: 'open' | 'create' | 'update' | 'enter' | 'leave' | 'delete' | 'close',
listener: (object: Object) => void
): this;
/**
* Closes the subscription.
*
*/
unsubscribe(): void;
}
/**
* Represents a Role on the Moralis 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.
* A Moralis.Role is a local representation of a role persisted to the Moralis
* cloud.
*/
interface Role extends Object {
getRoles(): Relation;
getUsers(): Relation;
getName(): string;
setName(name: string, options?: SuccessFailureOptions): any;
}
interface RoleConstructor extends ObjectStatic {
new (name: string, acl: ACL): Role>;
new (name: string, acl: ACL): Role;
}
const Role: RoleConstructor;
class Config {
static get(options?: UseMasterKeyOption): Promise;
static current(): Config;
static save(attr: any, options?: { [attr: string]: boolean }): Promise;
get(attr: string): any;
escape(attr: string): any;
}
interface Session extends Object {
getSessionToken(): string;
isCurrentSessionRevocable(): boolean;
}
interface SessionConstructor extends ObjectStatic {
new (attributes: T): Session;
new (): Session;
current(): Promise;
}
const Session: SessionConstructor;
/**
*
* A Moralis.User object is a local representation of a user persisted to the
* Moralis cloud. This class is a subclass of a Moralis.Object, and retains the
* same functionality of a Moralis.Object, but also extends it with various
* user specific methods, like authentication, signing up, and validation of
* uniqueness.
*/
interface User extends Object {
signUp(attrs?: any, options?: SignUpOptions): Promise;
logIn(options?: FullOptions): 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;
linkWith: (
provider: string | AuthProvider,
options: { authData?: AuthData },
saveOpts?: FullOptions
) => Promise;
_linkWith: (
provider: string | AuthProvider,
options: { authData?: AuthData },
saveOpts?: FullOptions
) => Promise;
_isLinked: (provider: string | AuthProvider) => boolean;
_unlinkFrom: (provider: string | AuthProvider, options?: FullOptions) => Promise;
}
interface UserConstructor extends ObjectStatic {
new (attributes: T): User;
new (attributes?: Attributes): User;
allowCustomUserClass(isAllowed: boolean): void;
become(sessionToken: string, options?: UseMasterKeyOption): Promise;
me(sessionToken: string, options?: UseMasterKeyOption): Promise;
current(): T | undefined;
currentAsync(): Promise;
signUp(
username: string,
password: string,
attrs: any,
options?: SignUpOptions
): Promise;
logIn(username: string, password: string, options?: FullOptions): Promise;
logOut(): Promise;
requestPasswordReset(
email: string,
options?: SuccessFailureOptions
): Promise;
extend(protoProps?: any, classProps?: any): any;
hydrate(userJSON: any): Promise;
enableUnsafeCurrentUser(): void;
logInWith(
provider: string | AuthProvider,
options: { authData?: AuthData },
saveOpts?: FullOptions
): Promise;
_registerAuthenticationProvider: (provider: AuthProvider) => void;
}
const User: UserConstructor;
/**
* A Moralis.Schema object is for handling schema data from Moralis.
* All the schemas methods require MasterKey.
*
* @param className Moralis Class string
*
* https://docs.moralis.io/Moralis-SDK-JS/api/master/Moralis.Schema.html
*
* ```
* const schema = new Moralis.Schema('MyClass');
* schema.addString('field');
* schema.addIndex('index_name', { field: 1 });
* schema.save();
* ```
*/
class Schema {
constructor(className: string);
/**
* Static method to get all schemas
*
* @return A promise that is resolved with the result when
* the query completes.
*/
static all(): Promise;
addArray(key: Schema.AttrType, options?: Schema.FieldOptions): this;
addBoolean(key: Schema.AttrType, options?: Schema.FieldOptions): this;
addDate(key: Schema.AttrType, options?: Schema.FieldOptions): this;
addField(
name: string,
type?: T,
options?: Schema.FieldOptions
): this;
addFile(key: Schema.AttrType, options?: Schema.FieldOptions): this;
addGeoPoint(key: Schema.AttrType, options?: Schema.FieldOptions): this;
/**
* Adding an Index to Create / Update a Schema
* @param name Name of the field that will be created on Moralis
* @param index `{ 'field': value }` where `field` should exist in the schema before using addIndex.
* @return Returns the schema, so you can chain this call.
* @example
* ```
* schema.addIndex('index_name', {'field': 1});
* ```
*/
addIndex(name: string, index: Schema.Index): this;
addNumber(key: Schema.AttrType