@ohos-ports/genesys-cloud-streaming-client 20.1.0-beta.1

package/dist/cjs/connection-manager.d.ts

@@ -0,0 +1,18 @@
+import Logger from 'genesys-cloud-client-logger';
+import { IClientConfig } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+export declare class ConnectionManager {
+    private logger;
+    private config;
+    currentStanzaInstance?: NamedAgent;
+    constructor(logger: Logger, config: IClientConfig);
+    setConfig(config: IClientConfig): void;
+    getNewStanzaConnection(): Promise<NamedAgent>;
+    private handleSessionStarted;
+    private handleSessionSasl;
+    private handleSessionDisconnected;
+    private checkForErrorStanza;
+    private getStanzaOptions;
+    private getJwtOptions;
+    private getStandardOptions;
+}

package/dist/cjs/connection-manager.js

@@ -0,0 +1,120 @@
+"use strict";
+// so the idea here is any time stanza gets disconnected, we are effectively going to kill that instance of
+// stanza and never reuse it. We may reuse the config for a given stanza client, but every connection attempt
+// will merit its own brand new client. The purpose of this is because the stanza.connect() is not transactional
+// and failed connection attempts trigger `disconnect` events either by timeout or some actual error. This is
+// a problem because it effectively means we can get multiple disconnect events for a single connection attempt
+// which makes trying to reconnect a stanza instance an tricky endeavor because we don't know if a disconnect
+// event applies to a past connection attempt or if it applies to the most recent connection attempt. For this
+// reason, we want a vanilla instance of stanza every time we call `connect` so wires don't get crossed.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionManager = void 0;
+const stanza_1 = require("stanza");
+const sasl_error_1 = __importDefault(require("./types/sasl-error"));
+const utils_1 = require("./utils");
+class ConnectionManager {
+    constructor(logger, config) {
+        this.logger = logger;
+        this.config = config;
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    async getNewStanzaConnection() {
+        const options = this.getStanzaOptions();
+        const stanza = (0, stanza_1.createClient)({});
+        this.currentStanzaInstance = stanza;
+        // this is a hack because stanza messes up the auth mechanism priority.
+        stanza.sasl.mechanisms.find(mech => mech.name === 'ANONYMOUS').priority = 0;
+        stanza.sasl.mechanisms = stanza.sasl.mechanisms.sort((a, b) => b.priority - a.priority);
+        // we are going to give the stanza instance an id for tracking and logging purposes
+        stanza.id = globalThis.crypto.randomUUID();
+        const channelId = stanza.channelId = this.config.channelId;
+        let boundCheckForErrorStanza;
+        let boundSessionStarted;
+        let boundSessionSasl;
+        let boundSessionDisconnected;
+        const connectionAttemptPromise = (0, utils_1.timeoutPromise)((resolve, reject) => {
+            boundCheckForErrorStanza = this.checkForErrorStanza.bind(this, stanza);
+            stanza.on('raw:incoming', boundCheckForErrorStanza);
+            boundSessionStarted = this.handleSessionStarted.bind(this, stanza, resolve);
+            stanza.on('session:started', boundSessionStarted);
+            boundSessionSasl = this.handleSessionSasl.bind(this, stanza, reject);
+            stanza.on('sasl', boundSessionSasl);
+            boundSessionDisconnected = this.handleSessionDisconnected.bind(this, stanza, reject);
+            stanza.on('disconnected', boundSessionDisconnected);
+            stanza.updateConfig(options);
+            stanza.connect();
+        }, 15 * 1000, 'connecting to streaming service', { channelId, stanzaInstanceId: stanza.id });
+        connectionAttemptPromise.catch(() => stanza.disconnect());
+        return connectionAttemptPromise.finally(() => {
+            stanza.off('raw:incoming', boundCheckForErrorStanza);
+            stanza.off('session:started', boundSessionStarted);
+            stanza.off('sasl', boundSessionSasl);
+            stanza.off('disconnected', boundSessionDisconnected);
+        });
+    }
+    handleSessionStarted(stanza, resolve) {
+        this.logger.info('new stanza instance connected', { stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        resolve(stanza);
+    }
+    handleSessionSasl(stanza, reject, sasl) {
+        if (sasl.type === 'failure') {
+            reject(new sasl_error_1.default(sasl.condition, stanza.channelId, stanza.id));
+        }
+    }
+    handleSessionDisconnected(stanza, reject) {
+        this.logger.error('stanza disconnected', { stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        reject();
+    }
+    checkForErrorStanza(stanza, rawStanza) {
+        if (rawStanza.includes('error')) {
+            this.logger.error('Received a stanza during setup that tripped the error filter', { rawStanza, stanzaInstanceId: stanza.id, channelId: stanza.channelId });
+        }
+    }
+    getStanzaOptions() {
+        if (this.config.jwt) {
+            return this.getJwtOptions();
+        }
+        return this.getStandardOptions();
+    }
+    getJwtOptions() {
+        const config = this.config;
+        const jwt = (0, utils_1.parseJwt)(config.jwt);
+        let jidDomain;
+        const jwtJid = jwt.data.jid;
+        try {
+            jidDomain = jwtJid.split('@')[1].replace('conference.', '');
+        }
+        catch (e) {
+            throw new Error('failed to parse jid');
+        }
+        const wsHost = config.host.replace(/\/$/, '');
+        return {
+            resource: config.jidResource,
+            transports: {
+                websocket: `${wsHost}/stream/jwt/${config.jwt}`
+            },
+            server: jidDomain
+        };
+    }
+    getStandardOptions() {
+        const config = this.config;
+        const wsHost = config.host.replace(/\/$/, '');
+        return {
+            jid: config.jid,
+            resource: config.jidResource,
+            credentials: {
+                username: config.jid,
+                password: `authKey:${config.authToken}`
+            },
+            transports: {
+                websocket: `${wsHost}/stream/channels/${config.channelId}`
+            }
+        };
+    }
+}
+exports.ConnectionManager = ConnectionManager;

package/dist/cjs/connection-transfer.d.ts

@@ -0,0 +1,7 @@
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+export declare class ConnectionTransfer {
+    private client;
+    private stanzaInstance;
+    constructor(client: Client, stanzaInstance: NamedAgent);
+}

package/dist/cjs/connection-transfer.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectionTransfer = void 0;
+const xep0051_1 = require("./stanza-definitions/xep0051");
+class ConnectionTransfer {
+    constructor(client, stanzaInstance) {
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+        stanzaInstance.stanzas.define(xep0051_1.connectionTransfer);
+        // Hawk maps `v2.system.socket_closing` to XEP-0051 Connection Transfer
+        // The docs says we have up to one minute to disconnect and connect a new WebSocket, so we should be proactive in reconnecting.
+        stanzaInstance.on('iq:set:connectionTransfer', (iq) => {
+            client.logger.warn('connection transfer (socket_closing) event received', { stanzaInstanceId: stanzaInstance.id, channelId: stanzaInstance.channelId });
+            void client.disconnect();
+            client.emit('disconnected', { reconnecting: true });
+            void client.connect({ keepTryingOnFailure: true });
+        });
+    }
+}
+exports.ConnectionTransfer = ConnectionTransfer;

package/dist/cjs/http-client.d.ts

@@ -0,0 +1,18 @@
+import { RetryPromise } from './utils';
+import { RequestApiOptions, ISuperagentNetworkError, ISuperagentResponseError, INetworkError, IResponseError, ICustomHeader, IHttpClientOptions } from './types/interfaces';
+export declare class HttpClient {
+    customHeaders?: ICustomHeader;
+    private _httpRetryingRequests;
+    static retryStatusCodes: Set<number>;
+    static retryNetworkErrorCodes: Set<string>;
+    constructor(httpClientOptions?: IHttpClientOptions);
+    requestApiWithRetry<T = any>(path: string, opts: RequestApiOptions, retryInterval?: number): RetryPromise<T>;
+    requestApi(path: string, opts: RequestApiOptions): Promise<any>;
+    private handleResponse;
+    stopAllRetries(): void;
+    cancelRetryRequest(retryId: string): true;
+    formatRequestError(error: Error | ISuperagentNetworkError | ISuperagentResponseError): Error | INetworkError | IResponseError;
+    private isSuperagentNetworkError;
+    private isSuperagentResponseError;
+    private _buildUri;
+}

package/dist/cjs/http-client.js

@@ -0,0 +1,230 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const axios_1 = __importStar(require("axios"));
+const utils_1 = require("./utils");
+const correlationIdHeaderName = 'inin-correlation-id';
+class HttpClient {
+    constructor(httpClientOptions) {
+        this._httpRetryingRequests = new Map();
+        this.customHeaders = httpClientOptions === null || httpClientOptions === void 0 ? void 0 : httpClientOptions.customHeaders;
+    }
+    requestApiWithRetry(path, opts, retryInterval) {
+        const maxRetries = opts.maxAttempts || 10;
+        let retryCount = 0;
+        const retry = (0, utils_1.retryPromise)(this.requestApi.bind(this, path, opts), (error) => {
+            var _a, _b, _c;
+            retryCount++;
+            if (retryCount >= maxRetries) {
+                (opts.logger || console).info('Max retries reached, will not retry.', { maxRetries, retryCount, path });
+                return false;
+            }
+            let retryValue = false;
+            if (error === null || error === void 0 ? void 0 : error.response) {
+                retryValue = HttpClient.retryStatusCodes.has(error.response.status || 0);
+                // This *should* be an axios error according to typings, but it appears this could be an AxiosError *or* and XmlHttpRequest
+                // we'll check both to be safe
+                const retryAfter = ((_a = error.response.headers) === null || _a === void 0 ? void 0 : _a['retry-after']) || ((_c = (_b = error.response).getResponseHeader) === null || _c === void 0 ? void 0 : _c.call(_b, 'retry-after'));
+                if (retryAfter) {
+                    (opts.logger || console).debug('retry-after header found on response. setting retry delay', { retryAfter });
+                    // retry after comes in seconds, we need to return milliseconds
+                    retryValue = parseInt(retryAfter, 10) * 1000;
+                }
+            }
+            // Check network error codes independently - error may have both response (with status 0) and a network error code.
+            if ((error === null || error === void 0 ? void 0 : error.code) && retryValue === false) {
+                // Retry on network error codes - request didn't make it to the server or no response was received
+                if (HttpClient.retryNetworkErrorCodes.has(error.code)) {
+                    (opts.logger || console).debug('Retry network error code found, will retry.', { code: error.code });
+                    retryValue = true;
+                }
+            }
+            return retryValue;
+        }, retryInterval, opts.logger);
+        this._httpRetryingRequests.set(retry._id, retry);
+        retry.promise.then(() => this.cancelRetryRequest(retry._id), () => this.cancelRetryRequest(retry._id));
+        return retry;
+    }
+    requestApi(path, opts) {
+        const logger = opts.logger || console;
+        const start = new Date().getTime();
+        opts.customHeaders = {
+            ...(this.customHeaders || {}),
+            ...(opts.customHeaders || {})
+        };
+        const url = this._buildUri(opts.host, path, opts.version);
+        const headers = {
+            'content-type': opts.contentType || 'application/json',
+            ...opts.customHeaders
+        };
+        const params = {
+            method: opts.method,
+            url,
+            data: opts.data,
+            responseType: opts.responseType,
+            timeout: opts.requestTimeout || 30000,
+            headers,
+            signal: opts.signal
+        };
+        // default to include auth header
+        if (!opts.noAuthHeader) {
+            params.headers.Authorization = `Bearer ${opts.authToken}`;
+        }
+        const boundHandler = this.handleResponse.bind(this, logger, start, params);
+        return (0, axios_1.default)(params)
+            .then(boundHandler, boundHandler);
+    }
+    handleResponse(logger, start, params, res) {
+        var _a, _b, _c;
+        const now = new Date().getTime();
+        const elapsed = (now - start) + 'ms';
+        if (res instanceof axios_1.AxiosError) {
+            // sanitize the auth token
+            if ((_b = (_a = res.config) === null || _a === void 0 ? void 0 : _a.headers) === null || _b === void 0 ? void 0 : _b.Authorization) {
+                res.config.headers.Authorization = 'redacted';
+            }
+            // handles request timeout
+            if (res.code === 'ECONNABORTED') {
+                logger.debug(`request error: ${params.url}`, {
+                    message: res.message,
+                    now,
+                    elapsed
+                }, { skipServer: true });
+                return Promise.reject(res);
+            }
+            /* istanbul ignore next */
+            const response = res.response || {};
+            const status = response.status;
+            const correlationId = response.headers && response.headers[correlationIdHeaderName];
+            const body = response.data;
+            const error = {
+                ...res,
+                text: (_c = response.request) === null || _c === void 0 ? void 0 : _c.response
+            };
+            logger.debug(`request error: ${params.url}`, {
+                message: res.message,
+                now,
+                elapsed,
+                status,
+                correlationId,
+                body
+            }, { skipServer: true });
+            return Promise.reject(error);
+        }
+        const status = res.status;
+        const correlationId = res.headers[correlationIdHeaderName];
+        const body = JSON.stringify(res.data);
+        logger.debug(`response: ${params.method.toUpperCase()} ${params.url}`, {
+            now,
+            status,
+            elapsed,
+            correlationId,
+            body
+        }, { skipServer: true });
+        return Promise.resolve(res);
+    }
+    stopAllRetries() {
+        Array.from(this._httpRetryingRequests.keys())
+            .forEach(key => this.cancelRetryRequest(key));
+    }
+    cancelRetryRequest(retryId) {
+        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'));
+            this._httpRetryingRequests.delete(retryId);
+        }
+        return true;
+    }
+    formatRequestError(error) {
+        /* if network error */
+        if (this.isSuperagentNetworkError(error)) {
+            return {
+                status: error.status,
+                method: error.method,
+                url: error.url,
+                crossDomain: error.crossDomain,
+                message: error.message,
+                name: error.name,
+                stack: error.stack
+            };
+        }
+        /* if superagent response error */
+        if (this.isSuperagentResponseError(error)) {
+            const res = error.response;
+            return {
+                status: error.status,
+                correlationId: res.headers['inin-correlation-id'],
+                // Potentially could contain PII
+                // responseBody: res.text,
+                // requestBody: res.req._data,
+                // url: res.error.url,
+                message: 'Error making HTTP request',
+                method: res.req.method,
+                name: res.error.name,
+                stack: res.error.stack
+            };
+        }
+        /* if we don't have a superagent error */
+        return error;
+    }
+    isSuperagentNetworkError(error) {
+        return (error &&
+            // these properties may have the value of `undefined` but they will still be set
+            error.hasOwnProperty('status') &&
+            error.hasOwnProperty('method') &&
+            error.hasOwnProperty('url'));
+    }
+    isSuperagentResponseError(error) {
+        return !!(error &&
+            error.response &&
+            error.response.body &&
+            error.response.req);
+    }
+    _buildUri(host, path, version = 'v2') {
+        path = path.replace(/^\/+|\/+$/g, ''); // trim leading/trailing /
+        if (host.indexOf('http') === 0) {
+            return `${host}/api/${version}/${path}`;
+        }
+        return `https://api.${host}/api/${version}/${path}`;
+    }
+}
+exports.HttpClient = HttpClient;
+HttpClient.retryStatusCodes = new Set([
+    408,
+    413,
+    429,
+    500,
+    502,
+    503,
+    504
+]);
+HttpClient.retryNetworkErrorCodes = new Set([
+    'ECONNABORTED',
+    'ECONNRESET',
+    'ERR_NETWORK',
+    'ETIMEDOUT'
+]);

package/dist/cjs/index.d.ts

@@ -0,0 +1,10 @@
+/// <reference path="types/libs.d.ts" />
+import { Client } from './client';
+export * from './types/genesys-cloud-media-session';
+export * from './types/stanza-media-session';
+export * from './types/media-session';
+export * from './types/interfaces';
+export * from './messenger';
+export { HttpClient } from './http-client';
+export { StreamingClientError, StreamingSubscriptionError, parseJwt } from './utils';
+export default Client;

package/dist/cjs/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJwt = exports.StreamingSubscriptionError = exports.StreamingClientError = exports.HttpClient = void 0;
+/// <reference path="types/libs.ts" />
+const client_1 = require("./client");
+__exportStar(require("./types/genesys-cloud-media-session"), exports);
+__exportStar(require("./types/stanza-media-session"), exports);
+__exportStar(require("./types/media-session"), exports);
+__exportStar(require("./types/interfaces"), exports);
+__exportStar(require("./messenger"), exports);
+var http_client_1 = require("./http-client");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return http_client_1.HttpClient; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "StreamingClientError", { enumerable: true, get: function () { return utils_1.StreamingClientError; } });
+Object.defineProperty(exports, "StreamingSubscriptionError", { enumerable: true, get: function () { return utils_1.StreamingSubscriptionError; } });
+Object.defineProperty(exports, "parseJwt", { enumerable: true, get: function () { return utils_1.parseJwt; } });
+exports.default = client_1.Client;

package/dist/cjs/messenger.d.ts

@@ -0,0 +1,37 @@
+import { ReceivedMessage } from 'stanza/protocol';
+import { Client } from './client';
+import { NamedAgent } from './types/named-agent';
+import { GenesysMediaMessage, StreamingClientExtension } from './types/interfaces';
+import { Emitter } from 'strict-event-emitter';
+declare type MessageWithMediaMessage = {
+    from?: string;
+    id?: string;
+    to?: string;
+    mediaMessage: GenesysMediaMessage;
+};
+export declare type MediaMessageEvent = MessageWithMediaMessage & {
+    fromMyUser: boolean;
+    fromMyClient: boolean;
+};
+export declare type MessengerEvents = {
+    mediaMessage: [MediaMessageEvent];
+};
+export declare class MessengerExtension extends Emitter<MessengerEvents> implements StreamingClientExtension {
+    private client;
+    private stanzaInstance;
+    constructor(client: Client, stanzaInstance: NamedAgent);
+    get bareJid(): string;
+    handleStanzaInstanceChange(stanzaInstance: NamedAgent): void;
+    isMediaMessage(msg: any): msg is MessageWithMediaMessage;
+    handleMessage(msg: ReceivedMessage): void;
+    /**
+     * @param msg
+     * @returns Promise<messageId>
+     */
+    broadcastMessage(msg: MessageWithMediaMessage): Promise<string>;
+    get expose(): MessengerExtensionApi;
+}
+export interface MessengerExtensionApi extends Pick<Emitter<MessengerEvents>, 'on' | 'off' | 'once' | 'addListener' | 'removeListener'> {
+    broadcastMessage(msg: MessageWithMediaMessage): Promise<string>;
+}
+export {};

package/dist/cjs/messenger.js

@@ -0,0 +1,54 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessengerExtension = void 0;
+const strict_event_emitter_1 = require("strict-event-emitter");
+const JID_1 = require("stanza/JID");
+class MessengerExtension extends strict_event_emitter_1.Emitter {
+    constructor(client, stanzaInstance) {
+        super();
+        this.client = client;
+        this.stanzaInstance = stanzaInstance;
+    }
+    get bareJid() {
+        return (0, JID_1.toBare)(this.stanzaInstance.jid);
+    }
+    handleStanzaInstanceChange(stanzaInstance) {
+        this.stanzaInstance = stanzaInstance;
+    }
+    isMediaMessage(msg) {
+        return !!msg.mediaMessage;
+    }
+    handleMessage(msg) {
+        if (!this.isMediaMessage(msg)) {
+            return;
+        }
+        const fromMyClient = msg.from === this.stanzaInstance.jid;
+        const fromMyUser = (0, JID_1.toBare)(msg.from) === this.bareJid;
+        this.emit('mediaMessage', { ...msg, fromMyClient, fromMyUser });
+    }
+    /**
+     * @param msg
+     * @returns Promise<messageId>
+     */
+    async broadcastMessage(msg) {
+        const id = globalThis.crypto.randomUUID();
+        msg.id = id;
+        msg.from = this.stanzaInstance.jid;
+        if (!msg.to) {
+            msg.to = this.bareJid;
+        }
+        await this.stanzaInstance.send('message', msg);
+        return id;
+    }
+    get expose() {
+        return {
+            broadcastMessage: this.broadcastMessage.bind(this),
+            on: this.on.bind(this),
+            once: this.once.bind(this),
+            off: this.off.bind(this),
+            removeListener: this.removeListener.bind(this),
+            addListener: this.addListener.bind(this)
+        };
+    }
+}
+exports.MessengerExtension = MessengerExtension;

package/dist/cjs/notifications.d.ts

@@ -0,0 +1,94 @@
+import { PubsubEvent, PubsubSubscription, PubsubSubscriptionWithOptions } from 'stanza/protocol';
+import { Client } from './client';
+import { IClientOptions, StreamingClientExtension } from './types/interfaces';
+import { NamedAgent } from './types/named-agent';
+import { AxiosResponse } from 'axios';
+export declare class Notifications implements StreamingClientExtension {
+    client: Client;
+    stanzaInstance?: NamedAgent;
+    subscriptions: any;
+    bulkSubscriptions: any;
+    topicPriorities: any;
+    debouncedResubscribe: () => Promise<BulkSubscribeResult>;
+    enablePartialBulkResubscribe: boolean;
+    private internalSubscriptions;
+    private pendingBulkSubscribeRetry?;
+    private pendingConnectedWait?;
+    constructor(client: any, options?: IClientOptions);
+    get pubsubHost(): string;
+    handleStanzaInstanceChange(stanza: NamedAgent): void;
+    topicHandlers(topic: string): Array<(obj?: any) => void>;
+    pubsubEvent({ pubsub }: {
+        pubsub: PubsubEvent;
+    }): void;
+    xmppSubscribe(topic: string): Promise<PubsubSubscriptionWithOptions | void>;
+    xmppUnsubscribe(topic: string): Promise<PubsubSubscription | void>;
+    mapCombineTopics(topics: string[]): Array<{
+        id: string;
+    }>;
+    prioritizeTopicList(topics: Array<{
+        id: string;
+    }>): Array<{
+        id: string;
+    }>;
+    getTopicPriority(topic: string, returnDefault?: boolean): number;
+    truncateTopicList(topics: Array<{
+        id: string;
+    }>): Array<{
+        id: string;
+    }>;
+    makeBulkSubscribeRequest(topics: string[], options: any): Promise<AxiosResponse<ChannelTopicsEntityListing>>;
+    createSubscription(topic: string, handler: (obj?: any) => void): void;
+    removeSubscription(topic: string, handler: (obj?: any) => void): void;
+    removeTopicPriority(topic: string): void;
+    getActiveIndividualTopics(): string[];
+    resubscribe(): Promise<BulkSubscribeResult>;
+    subscriptionsKeepAlive(): void;
+    getTopicParts(topic: string): {
+        prefix: string;
+        postfixes: string[];
+    };
+    setTopicPriorities(priorities?: {}): void;
+    subscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean, priority?: number): Promise<TopicSubscribeResult>;
+    /**
+     * Use `_subscribeInternal` when subscribing to a topic from within streaming-client itself.
+     * Internal subscriptions won't be overwritten by subscriptions from consumers and will be prioritized
+     * over subscriptions from consumers.
+     */
+    _subscribeInternal(topic: string): Promise<PubsubSubscriptionWithOptions | void>;
+    unsubscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean): Promise<any>;
+    bulkSubscribe(topics: string[], options?: BulkSubscribeOpts, priorities?: {
+        [topicName: string]: number;
+    }): Promise<BulkSubscribeResult>;
+    get expose(): NotificationsAPI;
+}
+export interface NotificationsAPI {
+    subscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean, priority?: number): Promise<any>;
+    unsubscribe(topic: string, handler?: (..._: any[]) => void, immediate?: boolean): Promise<any>;
+    bulkSubscribe(topics: string[], options?: BulkSubscribeOpts, priorities?: {
+        [topicName: string]: number;
+    }): Promise<any>;
+}
+export interface BulkSubscribeOpts {
+    replace?: boolean;
+    force?: boolean;
+}
+export interface BulkSubscribeResult {
+    [topic: string]: TopicSubscribeResult;
+}
+export interface TopicSubscribeResult {
+    topic: string;
+    state: 'Permitted' | 'Rejected' | 'Unknown';
+    rejectionReason?: string;
+    missingPermissions?: string[];
+}
+export interface ChannelTopicResponseEntity {
+    id: string;
+    state: 'Permitted' | 'Rejected';
+    rejectionReason?: string;
+    missingPermissions?: string[];
+    selfUri?: string;
+}
+export interface ChannelTopicsEntityListing {
+    entities: ChannelTopicResponseEntity[];
+}