@harishreddym/baqend

import { Observable, Subscription } from 'rxjs'; /** * The global JSON type. */ export type json = object | any[]; /** * A generic class type. */ export interface Class<T> { new(...args: Array<any>): T; } /** * The global DB object to use. */ export const db: baqend; export default db; /** * Creates a new Acl object, with an empty rule set for an object */ export class Acl { constructor(metadata?: util.Metadata); readonly read: util.Permission; readonly write: util.Permission; /** Removes all acl rules, read and write access is public afterwards */ clear(): void; /** Copies permissions from another ACL */ copy(acl: Acl): Acl; /** Gets whenever all users and roles have the permission to read the object */ isPublicReadAllowed(): boolean; /** Sets whenever all users and roles should have the permission to read the object Note: All other allow read rules will be removed. */ setPublicReadAllowed(): void; /** Checks whenever the user or role is explicit allowed to read the object */ isReadAllowed(userOrRole: model.User | model.Role | string): boolean; /** Checks whenever the user or role is explicit denied to read the object */ isReadDenied(userOrRole: model.User | model.Role | string): boolean; /** Allows the given user or rule to read the object */ allowReadAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** Denies the given user or rule to read the object */ denyReadAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** Deletes any read allow/deny rule for the given user or role */ deleteReadAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** Gets whenever all users and roles have the permission to write the object */ isPublicWriteAllowed(): boolean; /** Sets whenever all users and roles should have the permission to write the object Note: All other allow write rules will be removed. */ setPublicWriteAllowed(): void; /** Checks whenever the user or role is explicit allowed to write the object */ isWriteAllowed(userOrRole: model.User | model.Role | string): boolean; /** Checks whenever the user or role is explicit denied to write the object */ isWriteDenied(userOrRole: model.User | model.Role | string): boolean; /** Allows the given user or rule to write the object */ allowWriteAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** Denies the given user or rule to write the object */ denyWriteAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** Deletes any write allow/deny rule for the given user or role */ deleteWriteAccess(...userOrRole: (model.User | model.Role | string)[]): Acl; /** A JSON representation of the set of rules */ toJSON(): json; /** Sets the acl rules form JSON */ fromJSON(json: json): void; } export class EntityManager extends util.Lockable { constructor(entityManagerFactory: EntityManagerFactory); readonly isOpen: boolean; token: string; readonly isCachingDisabled: boolean; readonly isDeviceRegistered: boolean; readonly log: util.Logger; readonly entityManagerFactory: EntityManagerFactory; readonly metamodel: metamodel.Metamodel; readonly code: util.Code; readonly modules: util.Modules; readonly me: model.User | null; readonly deviceMe: model.Device | null; readonly tokenStorage: util.TokenStorage; readonly bloomFilter: caching.BloomFilter; readonly bloomFilterRefresh: number; /** Connects this entityManager, used for synchronous and asynchronous initialization */ connected(connector: connector.Connector, connectData: object, tokenStorage: util.TokenStorage): void; /** Get an instance whose state may be lazily fetched If the requested instance does not exist in the database, the EntityNotFoundError is thrown when the instance state is first accessed. The application should not expect that the instance state will be available upon detachment, unless it was accessed by the application while the entity manager was open. */ getReference(entityClass: Class<binding.Entity> | string, key?: string): binding.Entity; /** Creates an instance of {@link query.Builder<T>} for query creation and execution The query results are instances of the resultClass argument. */ createQueryBuilder<T>(resultClass?: Class<T>): query.Builder<T>; /** Clear the persistence context, causing all managed entities to become detached Changes made to entities that have not been flushed to the database will not be persisted. */ clear(): void; /** Close an application-managed entity manager After the close method has been invoked, all methods on the EntityManager instance and any Query and TypedQuery objects obtained from it will throw the IllegalStateError except for transaction, and isOpen (which will return false). If this method is called when the entity manager is associated with an active transaction, the persistence context remains managed until the transaction completes. */ close(): void; /** Check if the instance is a managed entity instance belonging to the current persistence context */ contains(entity: binding.Entity): boolean; /** Check if an object with the id from the given entity is already attached */ containsById(entity: binding.Entity): boolean; /** Remove the given entity from the persistence context, causing a managed entity to become detached Unflushed changes made to the entity if any (including removal of the entity), will not be synchronized to the database. Entities which previously referenced the detached entity will continue to reference it. */ detach(entity: binding.Entity): Promise<binding.Entity>; /** Resolve the depth by loading the referenced objects of the given entity */ resolveDepth(entity: binding.Entity, options?: object): Promise<binding.Entity>; /** Search for an entity of the specified oid If the entity instance is contained in the persistence context, it is returned from there. */ load(entityClass: Class<binding.Entity> | string, oid: String, options?: object): Promise<binding.Entity>; insert(entity: binding.Entity, options: object): Promise<binding.Entity>; update(entity: binding.Entity, options: object): Promise<binding.Entity>; save(entity: binding.Entity, options: object, withoutLock?: boolean): Promise<binding.Entity>; optimisticSave(entity: binding.Entity, cb: Function): Promise<binding.Entity>; /** Returns all referenced sub entities for the given depth and root entity */ getSubEntities(entity: binding.Entity, depth: boolean | number, resolved?: binding.Entity[], initialEntity?: binding.Entity): binding.Entity[]; /** Returns all referenced one level sub entities for the given path */ getSubEntitiesByPath(entity: binding.Entity, path: string[]): binding.Entity[]; /** Delete the entity instance. */ delete(entity: binding.Entity, options: object): Promise<binding.Entity>; /** Synchronize the persistence context to the underlying database. */ flush(): Promise<any>; /** Make an instance managed and persistent. */ persist(entity: binding.Entity): void; /** Refresh the state of the instance from the database, overwriting changes made to the entity, if any. */ refresh(entity: binding.Entity, options: object): Promise<binding.Entity>; /** Attach the instance to this database context, if it is not already attached */ attach(entity: binding.Entity): void; /** Opens a new window use for OAuth logins */ openOAuthWindow(url: string, targetOrTitle: string, options: object): void; registerDevice(devicetype: string, subscription: object, device: model.Device): Promise<model.Device>; /** The given entity will be checked by the validation code of the entity type. */ validate(entity: binding.Entity): util.ValidationResult; /** Adds the given object id to the cacheWhiteList if needed. */ addToWhiteList(objectId: string): void; /** Adds the given object id to the cacheBlackList if needed. */ addToBlackList(objectId: string): void; /** Checks the freshness of the bloom filter and does a reload if necessary */ ensureBloomFilterFreshness(): void; /** Checks for a given id, if revalidation is required, the resource is stale or caching was disabled */ mustRevalidate(id: string): boolean; ensureCacheHeader(id: string, message: connector.Message, refresh: boolean): void; /** Creates a absolute url for the given relative one */ createURL(relativePath: string, authorize?: boolean): string; /** Requests a perpetual token for the given user Only users with the admin role are allowed to request an API token. */ requestAPIToken(entityClass: Class<binding.Entity> | Class<binding.Managed>, user: binding.User | String): Promise<any>; /** Revoke all created tokens for the given user This method will revoke all previously issued tokens and the user must login again. */ revokeAllTokens(entityClass: Class<binding.Entity> | Class<binding.Managed>, user: binding.User | String): Promise<any>; /** Constructor for a new List collection */ List(...args: U[]): U[]; /** Constructor for a new Set collection */ Set(collection?: Iterable): Set; /** Constructor for a new Map collection */ Map(collection?: Iterable<any>): Map<any, any>; /** Constructor for a new GeoPoint */ GeoPoint(latitude?: string | number | number[], longitude?: number): GeoPoint; User: binding.UserFactory; Role: binding.EntityFactory<model.Role>; Device: binding.DeviceFactory; [YourEntityClass: string]: any; File: binding.FileFactory; } /** * Creates a new EntityManagerFactory connected to the given destination */ export class EntityManagerFactory extends util.Lockable { constructor(options?: string | { host?: string, port?: number, secure?: boolean, basePath?: string, schema?: object, tokenStorage?: util.TokenStorage, tokenStorageFactory?: util.TokenStorageFactory, staleness?: number }); connection: connector.Connector; metamodel: metamodel.Metamodel; code: util.Code; tokenStorageFactory: util.TokenStorageFactory; /** Apply additional configurations to this EntityManagerFactory */ configure(options: { tokenStorage?: util.TokenStorage, tokenStorageFactory?: util.TokenStorageFactory, staleness?: number }): void; tokenStorage: util.TokenStorage; staleness: number; /** Connects this EntityManager to the given destination */ connect(hostOrApp: string, port?: number, secure?: boolean, basePath?: string): Promise<this>; /** Connects this EntityManager to the given destination */ connect(hostOrApp: string, secure?: boolean): Promise<this>; /** Creates a new Metamodel instance, which is not connected */ createMetamodel(): metamodel.Metamodel; /** Create a new application-managed EntityManager. */ createEntityManager(useSharedTokenStorage?: boolean): EntityManager; } /** * Creates a new GeoPoint instance From latitude and longitude From a json object Or an tuple of latitude and longitude */ export class GeoPoint { constructor(latitude?: string | number | number[], longitude?: number); /** Creates a GeoPoint with the user's current location, if available. */ static current(): Promise<GeoPoint>; longitude: number; latitude: number; /** Returns the distance from this GeoPoint to another in kilometers. */ kilometersTo(point: GeoPoint): number; /** Returns the distance from this GeoPoint to another in miles. */ milesTo(point: GeoPoint): number; /** Computes the arc, in radian, between two WGS-84 positions. The haversine formula implementation is taken from: {@link http://<a href="http://www.movable-type.co.uk/scripts/latlong.html}">www.movable-type.co.uk/scripts/latlong.html}</a> Returns the distance from this GeoPoint to another in radians. */ radiansTo(point: GeoPoint): number; /** A String representation in latitude, longitude format */ toString(): string; /** Returns a JSON representation of the GeoPoint */ toJSON(): json; static DEG_TO_RAD: number; static EARTH_RADIUS_IN_KILOMETERS: number; static EARTH_RADIUS_IN_MILES: number; } export interface baqend extends EntityManager { /** Configures the DB with additional config options */ configure(options: { tokenStorage?: util.TokenStorage, tokenStorageFactory?: util.TokenStorageFactory, staleness?: number }): baqend; /** Connects the DB with the server and calls the callback on success */ connect(hostOrApp: string, secure?: boolean, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: Error) => Promise<any> | any): Promise<EntityManager>; } /** * An event for a real-time query. */ export class RealtimeEvent<T> { constructor(); target: query.Node<T>; data: T; operation: string; matchType: string; initial: boolean; index: number; date: Date; } export namespace binding { /** * Adds a trailing slash to a string if it is missing */ export function trailingSlashIt(str: string): string; export class Accessor { constructor(); getValue(object: object, attribute: metamodel.Attribute): any; setValue(object: object, attribute: metamodel.Attribute, value: any): void; } export interface DeviceFactory extends binding.EntityFactory<model.Device> { readonly me: model.Device; readonly isRegistered: boolean; /** Loads the Public VAPID Key which can be used to subscribe a Browser for Web Push notifications */ loadWebPushKey(): Promise<ArrayBuffer>; /** Register a new device with the given device token and OS. */ register(os: string, tokenOrSubscription: string | Subscription, doneCallback: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.Device>; /** Register a new device with the given device token and OS. */ register(os: string, tokenOrSubscription: string | PushSubscription, device?: model.Device, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.Device>; /** Uses the info from the given {util.PushMessage} message to send an push notification. */ push(pushMessage: util.PushMessage, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Push message will be used to send a push notification to a set of devices */ PushMessage(devices?: Set<binding.Entity> | binding.Entity[], message?: string, subject?: string, sound?: string, badge?: number, data?: object): util.PushMessage; } export class Enhancer { constructor(); createProxy(superClass: Class<any>): Class<any>; static getBaqendType(typeConstructor: Class<any>): metamodel.ManagedType; static getIdentifier(typeConstructor: Class<any>): string; static setIdentifier(typeConstructor: Class<any>, identifier: string): void; enhance(type: metamodel.ManagedType, typeConstructor: Class<any>): void; /** Enhance the prototype of the type */ enhancePrototype(proto: object, type: metamodel.ManagedType): void; enhanceProperty(proto: object, attribute: metamodel.Attribute): void; } export class Entity extends binding.Managed { constructor(); id: string; key: string; readonly version: number; readonly acl: Acl; readonly createdAt: Date; readonly updatedAt: Date; /** Waits on the previously requested operation on this object completes */ ready(doneCallback?: (entity: this) => Promise<any> | any): Promise<this>; /** Attach this object to the given db */ attach(db: EntityManager): void; /** Saves the object. Inserts the object if it doesn't exists and updates the object if the object exist. */ save(options?: { force?: boolean, depth?: number | boolean, refresh?: boolean }, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Inserts a new object. Inserts the object if it doesn't exists and raise an error if the object already exist. */ insert(options?: { depth?: number | boolean, refresh?: boolean }, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Updates an existing object Updates the object if it exists and raise an error if the object doesn't exist. */ update(options?: { force?: boolean, depth?: number | boolean, refresh?: boolean }, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Resolves the referenced object in the specified depth Only unresolved objects will be loaded unless the refresh option is specified. Removed objects will be marked as removed. */ load(options?: { depth?: number | boolean, refresh?: boolean }, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Deletes an existing object */ delete(options?: { force?: boolean, depth?: number | boolean }, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Saves the object and repeats the operation if the object is out of date In each pass the callback will be called. Ths first parameter of the callback is the entity and the second one is a function to abort the process. */ optimisticSave(cb: Function, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<this>; /** Validates the entity by using the validation code of the entity type */ validate(): util.ValidationResult; /** Starts a partial update on this entity */ partialUpdate(operations?: json): partialupdate.EntityPartialUpdateBuilder<this>; /** Get all objects which refer to this object */ getReferencing(options?: { classes?: string[] }): Promise<binding.Entity>; /** Converts the object to an JSON-Object */ toJSON(options?: boolean | { excludeMetadata?: boolean, depth?: number | boolean }): json; } export interface EntityFactory<T> extends binding.ManagedFactory<T> { /** Loads the instance for the given id, or null if the id does not exists. */ load(id: string, options?: { depth?: number | boolean, refresh?: boolean, local?: boolean }, doneCallback?: (entity: T) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<T>; /** Gets an unloaded reference for the given id. */ ref(id: string): T; /** Creates a new instance and sets the DatabaseObject to the given json */ fromJSON(json: json): T; /** Creates a new query for this class */ find(): query.Builder<T>; /** Creates a new partial update for this class */ partialUpdate(id: string, partialUpdate?: json): partialupdate.EntityPartialUpdateBuilder<T>; } /** * This factory creates instances of type T, by invoking the {@link #new()} method or by instantiating this factory directly */ export interface Factory<T> { /** Creates a new instance of the factory type */ new(...args: any[]): T; /** Creates a new instance of the factory type */ newInstance(args?: any[]): T; } /** * Creates a file object, which represents one specific file reference. This File object can afterwards be used to up- and download the file contents or to retrieves and change the files metadata. * The file data can be uploaded and downloaded as: * <table class="table"> <tr> <th>type</th> <th>JavaScript type</th> <th>Description</th> </tr> <tr> <td>'arraybuffer'</td> <td>ArrayBuffer</td> <td>The content is represented as a fixed-length raw binary data buffer</td> </tr> <tr> <td>'blob'</th> <td>Blob</td> <td>The content is represented as a simple blob</td> </tr> <tr> <td>'json'</td> <td>object|array|string</td> <td>The file content is represented as json</td> </tr> <tr> <td>'text'</td> <td>string</td> <td>The file content is represented through the string</td> </tr> <tr> <td>'base64'</td> <td>string</td> <td>The file content as base64 encoded string</td> </tr> <tr> <td>'data-url'</td> <td>string</td> <td>A data url which represents the file content</td> </tr> </table> */ export class File { constructor(fileOptions: string | { id?: string, name?: string, parent?: string, path?: string, data: string | Blob | File | ArrayBuffer | json, type?: string, mimeType?: string, size?: number, eTag?: string, lastModified: string | Date, acl?: Acl, headers?: { [key: string]: string } }); readonly id: string; readonly url: string; readonly name: string; readonly mimeType: string; readonly acl: Acl; readonly lastModified?: Date; readonly createdAt?: Date; readonly eTag: string; readonly headers: { [key: string]: string }; readonly size: number; readonly bucket: string; readonly key: string; readonly path: string; readonly parent: string; readonly isMetadataLoaded: boolean; readonly isFolder: boolean; /** Parses an E-Tag header */ static parseETag(eTag?: string): string; /** Uploads the file content which was provided in the constructor or by uploadOptions.data */ upload(uploadOptions?: { data?: string | Blob | File | ArrayBuffer | json, type?: string, mimeType?: string, eTag?: string, lastModified?: string, acl?: Acl, headers?: { [key: string]: string }, force?: boolean, progress?: (event: ProgressEvent) => any }, doneCallback?: (file: binding.File) => any, failCallback?: (error: error.PersistentError) => any): Promise<binding.File>; /** Download a file and providing it in the requested type */ download(downloadOptions?: { type?: string, refresh?: string }, doneCallback?: (data: string | Blob | File | ArrayBuffer | json) => any, failCallback?: (error: error.PersistentError) => any): Promise<(string|Blob|File|ArrayBuffer|json)>; /** Deletes a file */ delete(deleteOptions?: { force?: boolean }, doneCallback?: (data: binding.File) => any, failCallback?: (error: error.PersistentError) => any): Promise<(binding.File|Array<binding.File>)>; /** Makes the given message a conditional request based on the file metadata */ conditional(msg: connector.Message, options: { force?: boolean }): void; /** Gets the file metadata of a file */ loadMetadata(options?: { refresh?: boolean }, doneCallback?: (file: binding.File) => any, failCallback?: (error: error.PersistentError) => any): Promise<binding.File>; /** Updates the matadata of this file. */ saveMetadata(options?: { force?: boolean }, doneCallback?: (file: binding.File) => any, failCallback?: (error: error.PersistentError) => any): Promise<binding.File>; /** Deserialize the given JSON file metadata back to this file instance If the JSON object contains an ID, it must match with this file ID, otherwise an exception is thrown. */ fromJSON(json: json): void; /** Serialize the file metadata of this object to json */ toJSON(): json; /** Checks whenever metadata are already loaded of the file, throws an error otherwise */ checkAvailable(): void; } export interface FileFactory extends binding.Factory<binding.File> { /** Creates a new FileFactory for the given type */ create(db: EntityManager): binding.FileFactory; /** Creates a new file */ newInstance(args?: any[]): binding.File; /** Deserialize the file metadata from a json object back to a new file instance */ fromJSON(json: json): binding.File; /** Updates the metadata of the root file directory formally the file "bucket" */ saveMetadata(bucket: string, metadata: { [key: string]: util.Permission } | { load?: util.Permission, insert?: util.Permission, update?: util.Permission, delete?: util.Permission, query?: util.Permission }, doneCallback?: (bucketMetadata: { [key: string]: util.Permission }) => any, failCallback?: (error: error.PersistentError) => any): Promise<void>; /** Gets the metadata of the root folder (formally the file "bucket") */ loadMetadata(bucket: string, options?: { refresh?: object }, doneCallback?: (bucketMetadata: { [key: string]: util.Permission }) => any, failCallback?: (error: error.PersistentError) => any): Promise<{ [key: string]: util.Permission }>; /** Lists all the buckets. */ listBuckets(doneCallback?: (files: binding.File[]) => any, failCallback?: (error: error.PersistentError) => any): Promise<binding.File[]>; /** Lists the files (and folders) in the given folder. */ listFiles(folderOrPath: binding.File | string, start: binding.File, count: number, doneCallback?: (files: binding.File[]) => any, failCallback?: (error: error.PersistentError) => any): Promise<binding.File[]>; /** Creates a new file object which represents the file at the given ID Data provided to the constructor will be uploaded by invoking {@link upload()}. */ new(fileOptions: string | { name?: string, parent?: string, data: string | Blob | File | ArrayBuffer | json, type?: string, mimeType?: string, eTag?: string, lastModified?: string, acl?: Acl, headers?: { [key: string]: string } }): binding.File; } /** * The default constructor, copy all given properties to this object */ export class Managed { constructor(properties?: { [key: string]: any }); /** Initialize the given instance */ static init(instance: binding.Managed, properties?: { [key: string]: any }): void; /** Creates a subclass of this class */ static extend(childClass: Class<any>): Class<any>; /** Converts the managed object to an JSON-Object. */ toJSON(): json; } export interface ManagedFactory<T> extends binding.Factory<T> { /** Creates a new instance of the factory type */ newInstance(args?: any[]): T; /** Creates a new instance and sets the Managed Object to the given json */ fromJSON(json: json): T; /** Adds methods to instances of this factories type */ addMethods(methods: { [key: string]: Function }): void; /** Add a method to instances of this factories type */ addMethod(name: string, fn: Function): void; methods: { [key: string]: Function }; readonly managedType: metamodel.ManagedType; readonly db: EntityManager; /** Creates a new instance of the of this type */ new(properties: { [key: string]: any }): T; } export class Role extends binding.Entity { constructor(); /** Test if the given user has this role */ hasUser(user: model.User): boolean; /** Add the given user to this role */ addUser(user: model.User): void; /** Remove the given user from this role */ removeUser(user: model.User): void; users: Set<model.User>; name: string; } export class User extends binding.Entity { constructor(); /** Change the password of the given user */ newPassword(currentPassword: string, password: string, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Change the username of the current user */ changeUsername(newUsername: string, password: string, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Requests a perpetual token for the user Only users with the admin role are allowed to request an API token. */ requestAPIToken(doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; username: string; inactive: boolean; } export interface UserFactory extends binding.EntityFactory<model.User> { readonly me: model.User; /** Register a new user with the given username and password, if the username is not used by an another user. */ register(user: string | model.User, password: string, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Log in the user with the given username and password and starts a user session */ login(username: string, password: string, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Log in the user assiciated with the given token and starts a user session. */ loginWithToken(token: string, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Log out the current logged in user and ends the active user session */ logout(doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Change the password of the given user */ newPassword(username: string, password: string, newPassword: string, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Sends an email with a link to reset the password for the given username The username must be a valid email address. */ resetPassword(username: string, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Sends an email with a link to change the current username The user is identified by their current username and password. The username must be a valid email address. */ changeUsername(username: string, newUsername: string, password: string, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Requests a perpetual token for the given user Only users with the admin role are allowed to request an API token. */ requestAPIToken(user: binding.User | String, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Revoke all created tokens for the given user This method will revoke all previously issued tokens and the user must login again. */ revokeAllTokens(user: binding.User | String, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<any>; /** Change the password of a user, which will be identified by the given token from the reset password e-mail */ newPassword(token: string, newPassword: string, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Logs the user in with Google via OAuth Prompts the user for the Google login in a new window. Before using OAuth you need to setup your application on the provider website, add the redirect uri: <code>https://example.net/db/User/OAuth/google</code> and copy the client id and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in. */ loginWithGoogle(clientID: string, options?: { title?: string, width?: number, height?: number, scope?: string, state?: object, timeout?: number, redirect?: string }, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Logs the user in with Facebook via OAuth Prompts the user for the Facebook login in a new window. Before using OAuth you need to setup your application on the provider website, add the redirect uri: https://example.net/db/User/OAuth/facebook and copy the client id and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in. */ loginWithFacebook(clientID: string, options?: { title?: string, width?: number, height?: number, scope?: string, state?: object, timeout?: number, redirect?: string }, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Logs the user in with GitHub via OAuth Prompts the user for the GitHub login in a new window. Before using OAuth you need to setup your application on the provider website, add the redirect uri: https://example.net/db/User/OAuth/github and copy the client id and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in. */ loginWithGitHub(clientID: string, options?: { title?: string, width?: number, height?: number, scope?: string, state?: object, timeout?: number, redirect?: string }, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Logs the user in with Twitter via OAuth Prompts the user for the Twitter login in a new window. Before using OAuth you need to setup your application on the provider website, add the redirect uri: https://example.net/db/User/OAuth/twitter and copy the client id and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in. */ loginWithTwitter(clientID: string, options?: { title?: string, width?: number, height?: number, timeout?: number, redirect?: string }, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Logs the user in with LinkedIn via OAuth Prompts the user for the LinkedIn login in a new window. Before using OAuth you need to setup your application on the provider website, add the redirect uri: https://example.net/db/User/OAuth/linkedin and copy the client id and the client secret to your Baqend dashboard settings. When the returned promise succeeds the user is logged in. */ loginWithLinkedIn(clientID: string, options?: { title?: string, width?: number, height?: number, scope?: string, state?: object, timeout?: number, redirect?: string }, loginOption?: boolean | binding.UserFactory.LoginOption, doneCallback?: (entity: this) => Promise<any> | any, failCallback?: (error: error.PersistentError) => Promise<any> | any): Promise<model.User>; /** Creates a new user object */ new(properties: { [key: string]: any }): model.User; } export namespace UserFactory { export enum LoginOption { NO_LOGIN = -1, SESSION_LOGIN = 0, PERSIST_LOGIN = 1, } } } export namespace caching { /** * A Bloom Filter is a client-side kept cache sketch of the server cache */ export class BloomFilter { constructor(bloomFilter: { m: number, h: number, b: string }); readonly bytes: string; readonly bits: number; readonly hashes: number; readonly creation: number; /** Returns whether this Bloom filter contains the given element. */ contains(element: string): boolean; } } export namespace connector { export class Connector { constructor(host: string, port: number, secure: boolean, basePath: string); static create(host: string, port?: number, secure?: boolean, basePath?: string): connector.Connector; readonly host: string; readonly port: number; readonly secure: boolean; readonly basePath: string; readonly origin: string; send(message: connector.Message): Promise<connector.Message>; prepareRequest(message: connector.Message): void; /** Convert the message entity to the sendable representation */ toFormat(message: connector.Message): void; prepareResponse(message: connector.Message, response: object): Promise<any>; /** Convert received data to the requested response entity type */ fromFormat(response: object, entity: any, type: string): any; static RESPONSE_HEADERS: string[]; static connectors: connector.Connector[]; static connections: { [key: string]: connector.Connector }; } export class FetchConnector extends connector.Connector { constructor(); /** Indicates if this connector implementation is usable for the given host and port */ static isUsable(): boolean; } export class IFrameConnector extends connector.XMLHttpConnector { constructor(); /** Indicates if this connector implementation is usable for the given host and port */ static isUsable(host: string, port: number, secure: boolean): boolean; } export class Message { constructor(); /** Creates a new message class with the given message specification */ static create(specification: object): Class<Message>; /** Creates a new message class with the given message specification and a full path */ static createExternal(specification: object, members: object): Class<Message>; withCredentials: boolean; tokenStorage: util.TokenStorage; progressCallback: (event: ProgressEvent) => any; /** Gets the value of a the specified request header */ header(name: string): string; /** Sets the value of a the specified request header */ header(name: string, value: string): this; /** Sets the entity type */ entity(data: any, type?: 'json' | 'text' | 'blob' | 'buffer' | 'arraybuffer' | 'data-url' | 'form'): this; /** Get the mimeType */ mimeType(): string; /** Sets the mimeType */ mimeType(mimeType: string): this; /** Gets the contentLength */ contentLength(): number; /** Sets the contentLength */ contentLength(contentLength: number): this; /** Gets the request conditional If-Match header */ ifMatch(): string; /** Sets the request conditional If-Match header */ ifMatch(eTag: string): this; /** Gets the request a ETag based conditional header */ ifNoneMatch(): string; /** Sets the request a ETag based conditional header */ ifNoneMatch(eTag: string): this; /** Gets the request date based conditional header */ ifUnmodifiedSince(): string; /** Sets the request date based conditional header */ ifUnmodifiedSince(date: Date): this; /** Indicates that the request should not be served by a local cache */ noCache(): this; /** Gets the cache control header */ cacheControl(): string; /** Sets the cache control header */ cacheControl(value: string): this; /** Gets the ACL of a file into the Baqend-Acl header */ acl(): string; /** Sets and encodes the ACL of a file into the Baqend-Acl header */ acl(acl: Acl): this; /** Gets and encodes the custom headers of a file into the Baqend-Custom-Headers header */ customHeaders(): string; /** Sets and encodes the custom headers of a file into the Baqend-Custom-Headers header */ customHeaders(customHeaders: any): this; /** Gets the request accept header */ accept(): string; /** Sets the request accept header */ accept(accept: string): this; /** Gets the response type which should be returned */ responseType(): string; /** Sets the response type which should be returned */ responseType(type: string): this; /** Gets the progress callback */ progress(): (event: ProgressEvent) => any; /** Sets the progress callback */ progress(callback: (event: ProgressEvent) => any): this; /** Adds the given string to the request path If the parameter is an object, it will be serialized as a query string. */ addQueryString(query: string | { [key: string]: string }): this; /** Handle the receive */ doReceive(response: object): void; spec: object; } export class NodeConnector extends connector.Connector { constructor(); /** Parse the cookie header */ parseCookie(header: string): string | null; } export class XMLHttpConnector extends connector.Connector { constructor(); /** Indicates if this connector implementation is usable for the given host and port */ static isUsable(host: string, port: number, secure: boolean): boolean; } export class WebSocketConnector { constructor(url: String); static create(connector: connector.Connector, url?: String): connector.WebSocketConnector; openStream(tokenStorage: util.TokenStorage, id: string): connector.ObservableStream; static websockets: connector.Connector[]; } export class ObservableStream extends Observable<connector.ChannelMessage> { constructor(); /** Sends a message */ send(The: connector.ChannelMessage): any; } export interface ChannelMessage { id: string; type: string; date: Date; } export namespace Message { export enum StatusCode { NOT_MODIFIED = 304, BAD_CREDENTIALS = 460, BUCKET_NOT_FOUND = 461, INVALID_PERMISSION_MODIFICATION = 462, INVALID_TYPE_VALUE = 463, OBJECT_NOT_FOUND = 404, OBJECT_OUT_OF_DATE = 412, PERMISSION_DENIED = 466, QUERY_DISPOSED = 467, QUERY_NOT_SUPPORTED = 468, SCHEMA_NOT_COMPATIBLE = 469, SCHEMA_STILL_EXISTS = 470, SYNTAX_ERROR = 471, TRANSACTION_INACTIVE = 472, TYPE_ALREADY_EXISTS = 473, TYPE_STILL_REFERENCED = 474, SCRIPT_ABORTION = 475, } } } export namespace error { export class CommunicationError extends error.PersistentError { constructor(httpMessage: connector.Message, response: object); name: string; reason: string; status: number; } export class EntityExistsError extends error.PersistentError { constructor(entity: string); entity: binding.Entity; } export class IllegalEntityError extends error.PersistentError { constructor(entity: binding.Entity); entity: binding.Entity; } export class PersistentError extends Error { constructor(message: string, cause?: Error); } export class RollbackError extends error.PersistentError { constructor(cause: Error); } } export namespace message { /** * Get the list of all available subresources */ export class ListAllResources extends connector.Message { constructor(); } /** * Get the API version of the Orestes-Server */ export class ApiVersion extends connector.Message { constructor(); } /** * The Swagger specification of the Orestes-Server */ export class Specification extends connector.Message { constructor(); } /** * Returns all changed objects */ export class GetBloomFilter extends connector.Message { constructor(); } /** * Clears the Bloom filter (TTLs and stale entries) */ export class DeleteBloomFilter extends connector.Message { constructor(); } /** * Get the current Orestes config */ export class GetOrestesConfig extends connector.Message { constructor(); } /** * Updates the current Orestes config */ export class UpdateOrestesConfig extends connector.Message { constructor(body: json); } /** * Connects a browser to this server */ export class Connect extends connector.Message { constructor(); } /** * Gets the status of the server health */ export class Status extends connector.Message { constructor(); } /** * Gets the event Endpoint */ export class EventsUrl extends connector.Message { constructor(); } /** * Determines whether the IP has exceeded its rate limit */ export class BannedIp extends connector.Message { constructor(ip: string); } /** * Always returns banned status for proper CDN handling */ export class Banned extends connector.Message { constructor(); } /** * Clears all rate-limiting information for all IPs */ export class Unban extends connector.Message { constructor(); } /** * Clears rate-limiting information for given IPs */ export class UnbanIp extends connector.Message { constructor(ip: string); } /** * List all bucket names List all buckets */ export class GetBucketNames extends connector.Message { constructor(); } /** * List objects in bucket List all object ids of the given bucket */ export class GetBucketIds extends connector.Message { constructor(bucket: string, start: number, count: number); } /** * Dump objects of bucket Exports the complete data set of the bucket */ export class ExportBucket extends connector.Message { constructor(bucket: string); } /** * Upload all objects to the bucket Imports the complete data set. For large uploads, this call will always return the status code 200. If failures occur, they will be returned in the response body. */ export class ImportBucket extends connector.Message { constructor(bucket: string, body: json); } /** * Delete all objects in bucket Delete all objects in the given bucket */ export class TruncateBucket extends connector.Message { constructor(bucket: string); } /** * Create object Create the given object. The created object will get a unique id. */ export class CreateObject extends connector.Message { constructor(bucket: string, body: json); } /** * Get object Returns the specified object. Each object has one unique identifier and therefore only one URL. */ export class GetObject extends connector.Message { constructor(bucket: string, oid: string); } /** * Replace object Replace the current object with the updated one. To update a specific version of the object a version can be provided in the If-Match header. The update will only be accepted, if the current version matches the provided one, otherwise the update will be rejected. The * wildcard matches any existing object but prevents an insertion if the object does not exist. */ export class ReplaceObject extends connector.Message { constructor(bucket: string, oid: string, body: json); } /** * Delete object Deletes the object. The If-Match Header can be used to specify an expected version. The object will only be deleted if the version matches the provided one. The * wildcard can be used to match any existing version but results in an error if the object does not exist. */ export class DeleteObject extends connector.Message { constructor(bucket: string, oid: string); } /** * Get all available class schemas Gets the complete schema */ export class GetAllSchemas extends connector.Message { constructor(); } /** * Create new class schemas and update existing class schemas Updates the complete schema, merge all changes, reject the schema update if the schema changes aren't compatible */ export class UpdateAllSchemas extends connector.Message { constructor(body: json); } /** * Replace all currently created schemas with the new ones Replace the complete schema, with the new one. */ export class ReplaceAllSchemas extends connector.Message { constructor(body: json); } /** * Get the class schema Returns the schema definition of the class The class definition contains a link to its parent class and all persistable fields with there types of the class */ export class GetSchema extends connector.Message { constructor(bucket: string); } /** * Update the class schema Modify the schema definition of the class by adding all missing fields */ export class UpdateSchema extends connector.Message { constructor(bucket: string, body: json); } /** * Replace the class schema Replace the schema definition of the class */