genesys-cloud-streaming-client 13.5.0-develop.6 → 14.0.1-develop.9

package/dist/cjs/client.d.ts

@@ -37,6 +37,9 @@ export declare class Client {
     disconnect(): Promise<void>;
     reconnect(): Promise<void>;
     connect(): Promise<void>;
+    _connectStanza(): Promise<void>;
+    stopServerLogging(): void;
+    startServerLogging(): void;
     setAccessToken(token: string): void;
     static extend(namespace: any, extension: StreamingClientExtension | ((client: Client) => void)): void;
     static get version(): string;

package/dist/cjs/client.js

@@ -60,7 +60,7 @@ class Client {
     constructor(options) {
         this.connected = false;
         this.connecting = false;
-        this.autoReconnect = true;
+        this.autoReconnect = false;
         this.hardReconnectCount = 0;
         this.reconnectLeakTime = 1000 * 60 * 10; // 10 minutes
         this.deadChannels = [];
@@ -117,8 +117,9 @@ class Client {
         this.on('connected', async (event) => {
             this.streamId = event.resource;
             this._ping.start();
-            this.connected = true;
             this._reconnector.stop();
+            this.autoReconnect = true;
+            this.connected = true;
             this.connecting = false;
         });
         // remapped session:end
@@ -236,6 +237,7 @@ class Client {
     }
     disconnect() {
         this.logger.info('streamingClient.disconnect was called');
+        this.stopServerLogging();
         return utils_1.timeoutPromise(resolve => {
             this._stanzaio.once('disconnected', resolve);
             this.autoReconnect = false;
@@ -254,19 +256,11 @@ class Client {
         }, 10 * 1000, 'reconnecting streaming service');
     }
     connect() {
+        this.startServerLogging();
         this.logger.info('streamingClient.connect was called');
         this.connecting = true;
         if (this.config.jwt) {
-            return utils_1.timeoutPromise(resolve => {
-                this.once('connected', resolve);
-                const options = stanzaOptionsJwt(this.config);
-                this._stanzaio.updateConfig(options);
-                this._stanzaio.connect();
-            }, 10 * 1000, 'connecting to streaming service with jwt')
-                .catch((err) => {
-                this.connecting = false;
-                return Promise.reject(err);
-            });
+            return this._connectStanza();
         }
         let jidPromise;
         if (this.config.jid) {
@@ -280,7 +274,7 @@ class Client {
                 logger: this.logger
             };
             jidPromise = this.http.requestApiWithRetry('users/me', opts).promise
-                .then(res => res.body.chat.jabberId);
+                .then(res => res.data.chat.jabberId);
         }
         const opts = {
             method: 'post',
@@ -289,24 +283,62 @@ class Client {
             logger: this.logger
         };
         const channelPromise = this.http.requestApiWithRetry('notifications/channels?connectionType=streaming', opts).promise
-            .then(res => res.body.id);
+            .then(res => res.data.id);
         return Promise.all([jidPromise, channelPromise])
             .then(([jid, channelId]) => {
             this.config.jid = jid;
             this.config.channelId = channelId;
-            this.autoReconnect = true;
-            return utils_1.timeoutPromise(resolve => {
-                this.once('connected', resolve);
-                const options = stanzaioOptions(this.config);
-                this._stanzaio.updateConfig(options);
-                this._stanzaio.connect();
-            }, 10 * 1000, 'connecting to streaming service', { jid, channelId });
-        })
+            return this._connectStanza();
+        });
+    }
+    async _connectStanza() {
+        const guestConnection = !!this.config.jwt;
+        const timeoutMsg = 'connecting to streaming service';
+        const options = guestConnection ? stanzaOptionsJwt(this.config) : stanzaioOptions(this.config);
+        const timeoutDetails = guestConnection
+            ? { usingJwt: true }
+            : { channelId: this.config.channelId, jidResource: this.config.jidResource };
+        /* if we already have a WS, we need to wait for the 2nd disconnect */
+        let skipDisconnectEvent = !!this._stanzaio.transport;
+        let rejectCallback;
+        return utils_1.timeoutPromise((resolve, reject) => {
+            rejectCallback = () => {
+                if (skipDisconnectEvent) {
+                    this.logger.debug('received a --transport-disconnected event from existing WS. Not rejecting new attempt to connect WS.');
+                    skipDisconnectEvent = false;
+                }
+                else {
+                    this.logger.debug('received a --transport-disconnected event while attempting to connect new WS. rejecting new attempt to connect WS.');
+                    reject(new Error('unexpected disconnect from the WebSocket connecting streaming service'));
+                }
+            };
+            /* if stanza runs into an error, we want to reject right away. There is no reason to wait for our timeout */
+            this._stanzaio.on('--transport-disconnected', rejectCallback);
+            this.once('connected', resolve);
+            this._stanzaio.updateConfig(options);
+            this._stanzaio.connect();
+        }, 10 * 1000, timeoutMsg, timeoutDetails)
             .catch((err) => {
             this.connecting = false;
-            return Promise.reject(err);
+            /* if _we_ timed out but stanza is still trying to connect, we need to stop stanza's WS */
+            if (err.message === `Timeout: ${timeoutMsg}` && this._stanzaio.transport) {
+                this._stanzaio.disconnect();
+                this.logger.debug('timing out WS connect(), calling through to stanza to disconnect');
+            }
+            throw err;
+        }).finally(() => {
+            this._stanzaio.off('--transport-disconnected', rejectCallback);
         });
     }
+    stopServerLogging() {
+        /* flush all pending logs and webrtc stats – then turn off the logger */
+        this.logger.sendAllLogsInstantly();
+        this.logger.stopServerLogging();
+        this._webrtcSessions.flushStats();
+    }
+    startServerLogging() {
+        this.logger.startServerLogging();
+    }
     setAccessToken(token) {
         this.config.authToken = token;
         this.logger.setAccessToken(token);
@@ -318,7 +350,7 @@ class Client {
         extensions[namespace] = extension;
     }
     static get version() {
-        return '13.5.0';
+        return '14.0.1';
     }
 }
 exports.Client = Client;

package/dist/cjs/http-client.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpClient = void 0;
 const tslib_1 = require("tslib");
-const superagent_1 = tslib_1.__importDefault(require("superagent"));
-const request_logger_1 = tslib_1.__importDefault(require("./request-logger"));
+const axios_1 = tslib_1.__importStar(require("axios"));
 const utils_1 = require("./utils");
+const correlationIdHeaderName = 'inin-correlation-id';
 class HttpClient {
     constructor() {
         this._httpRetryingRequests = new Map();
@@ -17,14 +17,56 @@ class HttpClient {
         return retry;
     }
     requestApi(path, opts) {
-        let response = superagent_1.default[opts.method](this._buildUri(opts.host, path, opts.version))
-            .use(request_logger_1.default.bind(this, opts.logger, opts.data))
-            .type(opts.contentType || 'json');
+        const logger = opts.logger || console;
+        const start = new Date().getTime();
+        const url = this._buildUri(opts.host, path, opts.version);
+        const params = {
+            method: opts.method,
+            url,
+            headers: {
+                'content-type': opts.contentType || 'application/json',
+                // we may not need this
+                'accept-encoding': 'gzip, deflate'
+            }
+        };
         // default to include auth header
         if (!opts.noAuthHeader) {
-            response.set('Authorization', `Bearer ${opts.authToken}`);
+            params.headers['Authorization'] = `Bearer ${opts.authToken}`;
         }
-        return response.send(opts.data); // trigger request
+        const handleResponse = function (res) {
+            var _a;
+            let now = new Date().getTime();
+            let elapsed = (now - start) + 'ms';
+            if (res instanceof axios_1.AxiosError) {
+                /* istanbul ignore next */
+                const response = res.response || {};
+                let status = response.status;
+                let correlationId = (_a = response.headers) === null || _a === void 0 ? void 0 : _a[correlationIdHeaderName];
+                let body = response.data;
+                logger.debug(`request error: ${params.url}`, {
+                    message: res.message,
+                    now,
+                    elapsed,
+                    status,
+                    correlationId,
+                    body
+                }, true);
+                return Promise.reject(res);
+            }
+            let status = res.status;
+            let correlationId = res.headers[correlationIdHeaderName];
+            let body = JSON.stringify(res.data);
+            logger.debug(`response: ${opts.method.toUpperCase()} ${params.url}`, {
+                now,
+                status,
+                elapsed,
+                correlationId,
+                body
+            }, true);
+            return Promise.resolve(res);
+        };
+        return axios_1.default(params)
+            .then(handleResponse.bind(this), handleResponse.bind(this));
     }
     stopAllRetries() {
         Array.from(this._httpRetryingRequests.keys())
@@ -34,7 +76,7 @@ class HttpClient {
         const value = this._httpRetryingRequests.get(retryId);
         if (value) {
             /* if the promise has already completed, this will do nothing. Still need to remove it from the map */
-            value.cancel(new Error('Retry request cancelled'));
+            value.reject(new Error('Retry request cancelled'));
             this._httpRetryingRequests.delete(retryId);
         }
         return true;

package/dist/cjs/reconnector.d.ts

@@ -10,7 +10,7 @@ export declare class Reconnector {
     _backoffActive: boolean;
     _hardReconnectRetryInfo: null | RetryPromise<void>;
     constructor(client: any);
-    hardReconnect(): Promise<void>;
+    hardReconnect(maxAttempts?: number, interval?: number): Promise<void>;
     cleanupReconnect(): void;
     start(): void;
     stop(error?: Error | string): void;

package/dist/cjs/reconnector.js

@@ -95,13 +95,15 @@ class Reconnector {
         });
         this._backoffActive = false;
     }
-    async hardReconnect() {
+    async hardReconnect(maxAttempts, interval = HARD_RECONNECT_RETRY_MS) {
         if (this._hardReconnectRetryInfo) {
             return this._hardReconnectRetryInfo.promise;
         }
         this.cleanupReconnect();
         this._hasConnected = false;
-        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), this._shouldRetryError.bind(this), HARD_RECONNECT_RETRY_MS, this.client.logger);
+        this._hardReconnectRetryInfo = utils_1.retryPromise(this._attemptHardReconnect.bind(this), (error, retryCount) => {
+            return this._shouldRetryError(error, retryCount, maxAttempts);
+        }, interval, this.client.logger);
         try {
             await this._hardReconnectRetryInfo.promise;
             this._stopHardReconnect();
@@ -136,22 +138,32 @@ class Reconnector {
             if (typeof error === 'string') {
                 error = new Error(error);
             }
-            this._hardReconnectRetryInfo.cancel(error);
+            this._hardReconnectRetryInfo.reject(error);
         }
         else {
-            this._hardReconnectRetryInfo.complete();
+            this._hardReconnectRetryInfo.resolve();
         }
         this._hardReconnectRetryInfo = null;
     }
-    async _attemptHardReconnect() {
+    _attemptHardReconnect() {
         /* if we aren't online, don't retry the new channel */
         if (!navigator.onLine) {
             throw new Error(OFFLINE_ERROR);
         }
         this.client.logger.info('Attempting to reconnect with new channel.');
-        await this.client.connect();
+        return this.client.connect();
     }
-    _shouldRetryError(error) {
+    _shouldRetryError(error, attemptNumber, maxAttempts) {
+        if (typeof maxAttempts === 'number' && typeof attemptNumber === 'number') {
+            if (attemptNumber > maxAttempts) {
+                this.client.logger.debug('Max retry attempts reached trying to connect to new channel. Stopping retry', { attemptNumber, maxAttempts });
+                return false;
+            }
+            else {
+                this.client.logger.debug('Max retry attempts NOT reached trying to connect to new channel. Retrying', { attemptNumber, maxAttempts });
+                return true;
+            }
+        }
         /* we throw this is we are offline */
         if (error.message === OFFLINE_ERROR) {
             this.client.logger.debug('Browser is offline. Not attempting to reconnect with new channel.');

package/dist/cjs/types/retry-utils.d.ts

@@ -0,0 +1,54 @@
+import WildEmitter from 'wildemitter';
+export interface IRetryConfig<T = any> {
+    /**
+     * Function to attempt until it completes or rejects based on the
+     *  criteria for retrying.
+     */
+    promiseFn: () => Promise<T>;
+    /**
+     * Retry criteria to retry the promise function on failure. Available options:
+     * - `boolean`: if `true`, it will _always_ be retried. if `false`, it will _never_
+     *  be retried.
+     * - `number`: max attempts to retry
+     * - `function`: a function that accepts the error thrown and determines if it
+     *  should be retried. It will be passed the `Error` and the `attemptCount`.
+     *
+     * Default: `false`
+     */
+    retry?: boolean | number | ((error?: Error | any, attemptCount?: number) => boolean);
+    /**
+     * Milliseconds to wait inbetween next retry of the promise function on failure.
+     *
+     * Default: `15000`
+     */
+    retryInterval?: number;
+}
+export declare class RetryPromise<T = any> extends WildEmitter {
+    promise: Promise<T>;
+    _id: string;
+    private _reject;
+    private _resolve;
+    private _hasCompleted;
+    private _attemptCount;
+    private _timeout;
+    private _config;
+    constructor(config: IRetryConfig);
+    /**
+     * @deprecated use `reject(reason)`
+     * @param reason value to reject the promise with
+     * @returns void
+     */
+    cancel(reason?: string | Error | any): void;
+    reject(reason?: string | Error | any): void;
+    /**
+     * @deprecated use `resolve(reason)`
+     * @param value to resolve the promise with
+     * @returns void
+     */
+    complete(value: T | PromiseLike<T>): void;
+    resolve(value: T | PromiseLike<T>): void;
+    hasCompleted(): boolean;
+    attemptCount(): number;
+    private _tryPromiseFn;
+}
+export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retry?: boolean | number | ((error?: Error | any, attemptCount?: number) => boolean), retryInterval?: number, _logger?: any): RetryPromise<T>;

package/dist/cjs/types/retry-utils.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retryPromise = exports.RetryPromise = void 0;
+const tslib_1 = require("tslib");
+const uuid_1 = require("uuid");
+const wildemitter_1 = tslib_1.__importDefault(require("wildemitter"));
+class RetryPromise extends wildemitter_1.default {
+    constructor(config) {
+        super();
+        this._id = uuid_1.v4();
+        this._hasCompleted = false;
+        this._attemptCount = 0;
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+        this._config = {
+            promiseFn: config.promiseFn,
+            retry: config.retry || false,
+            retryInterval: config.retryInterval !== undefined && config.retryInterval > -1 ? config.retryInterval : 15000
+        };
+        /* tslint:disable:no-floating-promises */
+        this._tryPromiseFn();
+    }
+    /**
+     * @deprecated use `reject(reason)`
+     * @param reason value to reject the promise with
+     * @returns void
+     */
+    cancel(reason) {
+        return this.reject(reason);
+    }
+    reject(reason) {
+        this._reject(reason);
+        clearTimeout(this._timeout);
+        this._hasCompleted = true;
+        this.emit('rejected', reason);
+    }
+    /**
+     * @deprecated use `resolve(reason)`
+     * @param value to resolve the promise with
+     * @returns void
+     */
+    complete(value) {
+        return this.resolve(value);
+    }
+    resolve(value) {
+        this._resolve(value);
+        clearTimeout(this._timeout);
+        this._hasCompleted = true;
+        this.emit('resolved', value);
+    }
+    hasCompleted() {
+        return this._hasCompleted;
+    }
+    attemptCount() {
+        return this._attemptCount;
+    }
+    async _tryPromiseFn() {
+        const { retry, retryInterval } = this._config;
+        try {
+            this._attemptCount++;
+            this.emit('trying', {
+                attemptCount: this._attemptCount,
+                promise: this.promise
+            });
+            const val = await this._config.promiseFn();
+            this.resolve(val);
+        }
+        catch (error) {
+            if (
+            /* always retry */
+            retry === true ||
+                /* retry if under max retry attempts */
+                typeof retry === 'number' && this._attemptCount <= retry ||
+                /* retry if retry function returns true */
+                typeof retry === 'function' && retry(error, this._attemptCount + 1)) {
+                this.emit('retrying', {
+                    error,
+                    attemptCount: this._attemptCount,
+                    retryInterval
+                });
+                this._timeout = setTimeout(this._tryPromiseFn.bind(this), retryInterval);
+                return;
+            }
+            this.reject(error);
+        }
+    }
+}
+exports.RetryPromise = RetryPromise;
+function retryPromise(promiseFn, retry, retryInterval = 15000, _logger = console) {
+    return new RetryPromise({ promiseFn, retry, retryInterval });
+}
+exports.retryPromise = retryPromise;

package/dist/cjs/utils.d.ts

@@ -1,16 +1,9 @@
+export { retryPromise, RetryPromise } from './types/retry-utils';
 export declare function timeoutPromise(fn: Function, timeoutMs: number, msg: string, details?: any): Promise<void>;
 export declare function splitIntoIndividualTopics(topicString: string): string[];
 export declare const isAcdJid: (jid: string) => boolean;
 export declare const isScreenRecordingJid: (jid: string) => boolean;
 export declare const isSoftphoneJid: (jid: string) => boolean;
 export declare const isVideoJid: (jid: string) => boolean;
-export declare type RetryPromise<T = any> = {
-    promise: Promise<T>;
-    cancel: (reason?: string | Error) => void;
-    complete: (value?: T) => void;
-    hasCompleted: () => boolean;
-    _id: string;
-};
-export declare function retryPromise<T = any>(promiseFn: () => Promise<T>, retryFn: (error?: Error | any) => boolean, retryInterval?: number, logger?: any): RetryPromise<T>;
 export declare const parseJwt: (token: string) => any;
 export declare function calculatePayloadSize(trace: any): number;

package/dist/cjs/utils.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculatePayloadSize = exports.parseJwt = exports.retryPromise = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = void 0;
-const uuid_1 = require("uuid");
+exports.calculatePayloadSize = exports.parseJwt = exports.isVideoJid = exports.isSoftphoneJid = exports.isScreenRecordingJid = exports.isAcdJid = exports.splitIntoIndividualTopics = exports.timeoutPromise = exports.RetryPromise = exports.retryPromise = void 0;
+var retry_utils_1 = require("./types/retry-utils");
+Object.defineProperty(exports, "retryPromise", { enumerable: true, get: function () { return retry_utils_1.retryPromise; } });
+Object.defineProperty(exports, "RetryPromise", { enumerable: true, get: function () { return retry_utils_1.RetryPromise; } });
 function timeoutPromise(fn, timeoutMs, msg, details) {
     return new Promise(function (resolve, reject) {
         const timeout = setTimeout(function () {
@@ -35,66 +37,27 @@ function splitIntoIndividualTopics(topicString) {
     return topics;
 }
 exports.splitIntoIndividualTopics = splitIntoIndividualTopics;
-exports.isAcdJid = function (jid) {
+const isAcdJid = function (jid) {
     return jid.startsWith('acd-');
 };
-exports.isScreenRecordingJid = function (jid) {
+exports.isAcdJid = isAcdJid;
+const isScreenRecordingJid = function (jid) {
     return jid.startsWith('screenrecording-');
 };
-exports.isSoftphoneJid = function (jid) {
+exports.isScreenRecordingJid = isScreenRecordingJid;
+const isSoftphoneJid = function (jid) {
     if (!jid) {
         return false;
     }
     return !!jid.match(/.*@.*gjoll.*/i);
 };
-exports.isVideoJid = function (jid) {
+exports.isSoftphoneJid = isSoftphoneJid;
+const isVideoJid = function (jid) {
     return !!(jid && jid.match(/@conference/) && !exports.isAcdJid(jid));
 };
-function retryPromise(promiseFn, retryFn, retryInterval = 15000, logger = console) {
-    let timeout;
-    let cancel;
-    let complete;
-    let tryPromiseFn;
-    let _hasCompleted = false;
-    const promise = new Promise((resolve, reject) => {
-        tryPromiseFn = async () => {
-            try {
-                const val = await promiseFn();
-                complete(val);
-            }
-            catch (error) {
-                if (retryFn(error)) {
-                    logger.debug('Retrying promise', error);
-                    timeout = setTimeout(tryPromiseFn, retryInterval);
-                }
-                else {
-                    cancel(error);
-                }
-            }
-        };
-        complete = (value) => {
-            clearTimeout(timeout);
-            _hasCompleted = true;
-            resolve(value);
-        };
-        cancel = (reason) => {
-            clearTimeout(timeout);
-            _hasCompleted = true;
-            reject(reason);
-        };
-        tryPromiseFn();
-    });
-    return {
-        promise,
-        cancel,
-        complete,
-        _id: uuid_1.v4(),
-        hasCompleted: () => _hasCompleted
-    };
-}
-exports.retryPromise = retryPromise;
+exports.isVideoJid = isVideoJid;
 // from https://stackoverflow.com/questions/38552003/how-to-decode-jwt-token-in-javascript
-exports.parseJwt = (token) => {
+const parseJwt = (token) => {
     const base64Url = token.split('.')[1];
     const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
     const jsonPayload = decodeURIComponent(window.atob(base64).split('').map(function (c) {
@@ -102,6 +65,7 @@ exports.parseJwt = (token) => {
     }).join(''));
     return JSON.parse(jsonPayload);
 };
+exports.parseJwt = parseJwt;
 function calculatePayloadSize(trace) {
     const str = JSON.stringify(trace);
     // http://stackoverflow.com/questions/5515869/string-length-in-bytes-in-javascript

package/dist/cjs/webrtc.d.ts

@@ -46,6 +46,7 @@ export declare class WebrtcExtension extends EventEmitter {
         sessionId: string;
         sessionType?: SessionTypes;
     };
+    flushStats(): void;
     sendStats(): Promise<void>;
     addEventListeners(): void;
     proxyEvents(): void;

package/dist/cjs/webrtc.js

@@ -102,6 +102,10 @@ class WebrtcExtension extends events_1.EventEmitter {
     // This should be moved when the sdk is the primary consumer
     proxyStatsForSession(session) {
         session.on('stats', (statsEvent) => {
+            /* if our logger was stopped, we need to stop stats logging too */
+            if (this.client.logger['stopReason']) {
+                return;
+            }
             const statsCopy = JSON.parse(JSON.stringify(statsEvent));
             const extraDetails = {
                 conference: session.conversationId,
@@ -117,7 +121,7 @@ class WebrtcExtension extends events_1.EventEmitter {
             this.statBuffer += currentEventSize;
             // If it exceeds max size, don't append just send current payload.
             if (exceedsMaxStatSize) {
-                this.throttledSendStats.flush();
+                this.flushStats();
             }
             else {
                 this.throttledSendStats();
@@ -135,6 +139,9 @@ class WebrtcExtension extends events_1.EventEmitter {
         }
         return logDetails;
     }
+    flushStats() {
+        this.throttledSendStats.flush();
+    }
     async sendStats() {
         const statsToSend = [];
         let currentSize = 0;

package/dist/deploy-info.json

@@ -5,18 +5,18 @@
   "team": "Genesys Client Media (WebRTC)",
   "indexFiles": [
     {
-      "file": "/v13.5.0/streaming-client.browser.ie.js"
+      "file": "/v14.0.1/streaming-client.browser.ie.js"
     },
     {
-      "file": "/v13.5.0/streaming-client.browser.js"
+      "file": "/v14.0.1/streaming-client.browser.js"
     },
     {
-      "file": "/v13/streaming-client.browser.ie.js"
+      "file": "/v14/streaming-client.browser.ie.js"
     },
     {
-      "file": "/v13/streaming-client.browser.js"
+      "file": "/v14/streaming-client.browser.js"
     }
   ],
-  "build": "6",
-  "buildDate": "2022-05-28T00:07:49.984882Z"
+  "build": "9",
+  "buildDate": "2022-06-01T15:49:16.445265Z"
 }

package/dist/es/client.d.ts

@@ -37,6 +37,9 @@ export declare class Client {
     disconnect(): Promise<void>;
     reconnect(): Promise<void>;
     connect(): Promise<void>;
+    _connectStanza(): Promise<void>;
+    stopServerLogging(): void;
+    startServerLogging(): void;
     setAccessToken(token: string): void;
     static extend(namespace: any, extension: StreamingClientExtension | ((client: Client) => void)): void;
     static get version(): string;