kuzzle-sdk/src/Kuzzle.d.ts

import { KuzzleEventEmitter } from './core/KuzzleEventEmitter';
import { KuzzleAbstractProtocol } from './protocols/abstract/Base';
import { AuthController } from './controllers/Auth';
import { CollectionController } from './controllers/Collection';
import { DocumentController } from './controllers/Document';
import { IndexController } from './controllers/Index';
import { RealtimeController } from './controllers/Realtime';
import { JSONObject } from './types';
import { RequestPayload } from './types/RequestPayload';
import { ResponsePayload } from './types/ResponsePayload';
export declare class Kuzzle extends KuzzleEventEmitter {
    [key: string]: any;
    /**
     * Protocol used by the SDK to communicate with Kuzzle.
     */
    protocol: any;
    /**
     * If true, automatically renews all subscriptions on a reconnected event.
     */
    autoResubscribe: boolean;
    /**
     * Timeout before sending again a similar event.
     */
    eventTimeout: number;
    /**
     * SDK version.
     */
    sdkVersion: string;
    /**
     * SDK name (e.g: `js@7.4.2`).
     */
    sdkName: string;
    /**
     * Common volatile data that will be sent to all future requests.
     */
    volatile: JSONObject;
    auth: AuthController;
    bulk: any;
    collection: CollectionController;
    document: DocumentController;
    index: IndexController;
    ms: any;
    realtime: RealtimeController;
    security: any;
    server: any;
    private _protectedEvents;
    private _offlineQueue;
    private _autoQueue;
    private _autoReplay;
    private _offlineQueueLoader;
    private _queuing;
    private _queueFilter;
    private _queueMaxSize;
    private _queueTTL;
    private _replayInterval;
    private _tokenExpiredInterval;
    private _lastTokenExpired;
    private __proxy__;
    /**
     * Instantiate a new SDK
     *
     * @example
     *
     * import { Kuzzle, WebSocket } from 'kuzzle-sdk';
     *
     * const kuzzle = new Kuzzle(
     *   new WebSocket('localhost')
     * );
     */
    constructor(
    /**
     * Network protocol to connect to Kuzzle. (e.g. `Http` or `WebSocket`)
     */
    protocol: KuzzleAbstractProtocol, options?: {
        /**
         * Automatically renew all subscriptions on a `reconnected` event
         * Default: `true`
         */
        autoResubscribe?: boolean;
        /**
         * Time (in ms) during which a similar event is ignored
         * Default: `200`
         */
        eventTimeout?: number;
        /**
         * Common volatile data, will be sent to all future requests
         * Default: `{}`
         */
        volatile?: JSONObject;
        /**
         * If `true`, automatically queues all requests during offline mode
         * Default: `false`
         */
        autoQueue?: boolean;
        /**
         * If `true`, automatically replays queued requests
         * on a `reconnected` event
         * Default: `false`
         */
        autoReplay?: boolean;
        /**
         * Custom function called during offline mode to filter
         * queued requests on-the-fly
         */
        queueFilter?: (request: RequestPayload) => boolean;
        /**
         * Called before dequeuing requests after exiting offline mode,
         * to add items at the beginning of the offline queue
         */
        offlineQueueLoader?: (...any: any[]) => any;
        /**
         * Number of maximum requests kept during offline mode
         * Default: `500`
         */
        queueMaxSize?: number;
        /**
         * Time a queued request is kept during offline mode, in milliseconds
         * Default: `120000`
         */
        queueTTL?: number;
        /**
         * Delay between each replayed requests, in milliseconds
         * Default: `10`
         */
        replayInterval?: number;
        /**
         * Time (in ms) during which a TokenExpired event is ignored
         * Default: `1000`
         */
        tokenExpiredInterval?: number;
        /**
         * If set to `auto`, the `autoQueue` and `autoReplay` are also set to `true`
         */
        offlineMode?: 'auto';
    });
    get authenticated(): boolean;
    get autoQueue(): any;
    set autoQueue(value: any);
    get autoReconnect(): any;
    set autoReconnect(value: any);
    get autoReplay(): any;
    set autoReplay(value: any);
    get connected(): any;
    get host(): any;
    get jwt(): any;
    set jwt(encodedJwt: any);
    get offlineQueue(): any;
    get offlineQueueLoader(): any;
    set offlineQueueLoader(value: any);
    get port(): any;
    get queueFilter(): any;
    set queueFilter(value: any);
    get queueMaxSize(): any;
    set queueMaxSize(value: any);
    get queueTTL(): any;
    set queueTTL(value: any);
    get reconnectionDelay(): any;
    get replayInterval(): any;
    set replayInterval(value: any);
    get sslConnection(): any;
    get tokenExpiredInterval(): any;
    set tokenExpiredInterval(value: any);
    /**
    * Emit an event to all registered listeners
    * An event cannot be emitted multiple times before a timeout has been reached.
    */
    emit(eventName: any, ...payload: any[]): boolean;
    private _superEmit;
    /**
     * Connects to a Kuzzle instance
     */
    connect(): Promise<void>;
    /**
     * Adds a listener to a Kuzzle global event. When an event is fired, listeners are called in the order of their
     * insertion.
     *
     * @param {string} event - name of the global event to subscribe to
     * @param {function} listener - callback to invoke each time an event is fired
     */
    addListener(event: any, listener: any): this;
    private _superAddListener;
    /**
     * Empties the offline queue without replaying it.
     *
     * @returns {Kuzzle}
     */
    flushQueue(): this;
    /**
     * Disconnects from Kuzzle and invalidate this instance.
     */
    disconnect(): void;
    /**
     * This is a low-level method, exposed to allow advanced SDK users to bypass
     * high-level methods.
     * Base method used to send read queries to Kuzzle
     *
     * Takes an optional argument object with the following properties:
     *    - volatile (object, default: null):
     *        Additional information passed to notifications to other users
     *
     * @param request
     * @param options - Optional arguments
     */
    query(request?: RequestPayload, options?: JSONObject): Promise<ResponsePayload>;
    /**
     * Starts the requests queuing.
     */
    startQueuing(): this;
    /**
     * Stops the requests queuing.
     */
    stopQueuing(): this;
    /**
     * Plays the requests queued during offline mode.
     */
    playQueue(): this;
    /**
     * On token expiration, reset jwt and unsubscribe all rooms.
     * Throttles to avoid duplicate event triggers.
     */
    tokenExpired(): void;
    /**
     * Adds a new controller and make it available in the SDK.
     *
     * @param ControllerClass
     * @param accessor
     */
    useController(ControllerClass: any, accessor: string): this;
    private _checkPropertyType;
    /**
     * Clean up the queue, ensuring the queryTTL and queryMaxSize properties are respected
     */
    private _cleanQueue;
    /**
     * Play all queued requests, in order.
     */
    private _dequeue;
}