@twilio/conversations 2.0.1-rc.5 → 2.0.1-rc.9

package/dist/client.js

@@ -0,0 +1,872 @@
+/*
+@license
+The following license applies to all parts of this software except as
+documented below.
+
+    Copyright (c) 2019, Twilio, inc.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are
+    met:
+
+      1. Redistributions of source code must retain the above copyright
+         notice, this list of conditions and the following disclaimer.
+
+      2. Redistributions in binary form must reproduce the above copyright
+         notice, this list of conditions and the following disclaimer in
+         the documentation and/or other materials provided with the
+         distribution.
+
+      3. Neither the name of Twilio nor the names of its contributors may
+         be used to endorse or promote products derived from this software
+         without specific prior written permission.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+    HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+This software includes javascript-state-machine under the following license.
+
+    Copyright (c) 2012, 2013, 2014, 2015, Jake Gordon and contributors
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in all
+    copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+
+This software includes loglevel under the following license.
+
+    Copyright (c) 2013 Tim Perry
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation
+    files (the "Software"), to deal in the Software without
+    restriction, including without limitation the rights to use,
+    copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the
+    Software is furnished to do so, subject to the following
+    conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+    OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+    WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+This software includes q under the following license.
+
+    Copyright 2009–2014 Kristopher Michael Kowal. All rights reserved.
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to
+    deal in the Software without restriction, including without limitation the
+    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+    sell copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+    IN THE SOFTWARE.
+
+This software includes platform.js under the following license.
+
+    Copyright 2014 Benjamin Tan <https://d10.github.io/>
+    Copyright 2011-2015 John-David Dalton <http://allyoucanleet.com/>
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal in the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+
+    The above copyright notice and this permission notice shall be
+    included in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+    LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+    OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+    WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+*/
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib_es6 = require('./node_modules/tslib/tslib.es6.js');
+var logger = require('./logger.js');
+var configuration = require('./configuration.js');
+var user = require('./user.js');
+var network = require('./services/network.js');
+var notificationTypes = require('./interfaces/notification-types.js');
+var twilsock = require('twilsock');
+var notifications = require('@twilio/notifications');
+var twilioSync = require('twilio-sync');
+var mcsClient = require('@twilio/mcs-client');
+var conversations = require('./data/conversations.js');
+var users = require('./data/users.js');
+var typingIndicator = require('./services/typing-indicator.js');
+var pushNotification = require('./push-notification.js');
+var index = require('./util/index.js');
+var declarativeTypeValidator = require('@twilio/declarative-type-validator');
+var _package = require('./packages/conversations/package.json.js');
+var commandExecutor = require('./command-executor.js');
+var replayEventEmitter = require('@twilio/replay-event-emitter');
+
+var Client_1;
+const log = logger.Logger.scope('Client');
+const SDK_VERSION = _package.version;
+class ClientServices {
+}
+/**
+ * A client is the starting point to the Twilio Conversations functionality.
+ */
+exports.Client = Client_1 = class Client extends replayEventEmitter.ReplayEventEmitter {
+    /**
+     * Returned Conversations instance is not yet fully initialized. Calling any operations will block until it is.
+     * Use connection events to monitor when client becomes fully available (connectionStateChanged with state
+     * 'connected') or not available (connectionStateChange with state 'denied', event tokenExpired, event connectionError).
+     *
+     * @param fpaToken Access token
+     * @param options Options to customize the Client
+     * @returns A not yet fully-initialized client.
+     */
+    constructor(fpaToken, options = {}) {
+        var _a, _b, _c, _d, _e;
+        super();
+        /**
+         * Client connection state.
+         */
+        this.connectionState = 'unknown';
+        this.conversationsPromise = null;
+        this._ensureReady = null;
+        this._resolveEnsureReady = null;
+        this._rejectEnsureReady = null;
+        /**
+         * Current version of the Conversations client.
+         */
+        this.version = SDK_VERSION;
+        this.parsePushNotification = Client_1.parsePushNotification;
+        this.fpaToken = fpaToken;
+        this.options = options;
+        if (!this.options.disableDeepClone) {
+            let options = Object.assign(Object.assign({}, this.options), { transport: undefined, twilsockClient: undefined });
+            options = index.deepClone(options);
+            options.transport = this.options.transport;
+            options.twilsockClient = this.options.twilsockClient;
+            this.options = options;
+        }
+        this.options.logLevel = (_a = this.options.logLevel) !== null && _a !== void 0 ? _a : 'silent';
+        log.setLevel(this.options.logLevel);
+        const productId = this.options.productId = 'ip_messaging';
+        // Filling ClientMetadata
+        this.options.clientMetadata = this.options.clientMetadata || {};
+        if (!this.options.clientMetadata.hasOwnProperty('type')) {
+            this.options.clientMetadata.type = 'conversations';
+        }
+        if (!this.options.clientMetadata.hasOwnProperty('sdk')) {
+            this.options.clientMetadata.sdk = 'JS';
+            this.options.clientMetadata.sdkv = SDK_VERSION;
+        }
+        // Enable session local storage for Sync
+        this.options.Sync = this.options.Sync || {};
+        if (typeof this.options.Sync.enableSessionStorage === 'undefined') {
+            this.options.Sync.enableSessionStorage = true;
+        }
+        if (this.options.region) {
+            this.options.Sync.region = this.options.region;
+        }
+        if (!fpaToken) {
+            throw new Error('A valid Twilio token should be provided');
+        }
+        this.services = new ClientServices();
+        this._myself = new user.User('', '', null, this.services);
+        const startTwilsock = !this.options.twilsockClient;
+        // Create default init registrations if none were provided.
+        // Otherwise, the outside party have to list all the init registrations they
+        // need.
+        // Init registrations passed to the Conversations client will be passed down
+        // to the Sync client as well.
+        if (!this.options.initRegistrations) {
+            const initRegistration = new twilsock.InitRegistration(productId);
+            Client_1.populateInitRegistrations(initRegistration);
+            this.options.initRegistrations = [initRegistration];
+        }
+        this.services.twilsockClient = (this.options.twilsockClient = (_b = this.options.twilsockClient) !== null && _b !== void 0 ? _b : new twilsock.TwilsockClient(fpaToken, productId, this.options));
+        this.services.twilsockClient.on('tokenAboutToExpire', ttl => this.emit('tokenAboutToExpire', ttl));
+        this.services.twilsockClient.on('tokenExpired', () => this.emit('tokenExpired'));
+        this.services.twilsockClient.on('connectionError', (error) => this.emit('connectionError', error));
+        this.services.twilsockClient.on('stateChanged', (state) => {
+            log.debug(`Handling stateChanged for ConversationsClient: new state ${state}`);
+            if (state !== this.connectionState) {
+                this.connectionState = state;
+                this.emit('connectionStateChanged', this.connectionState);
+            }
+        });
+        this.services.transport = (this.options.transport = ((_c = this.options.transport) !== null && _c !== void 0 ? _c : this.options.twilsockClient));
+        this.services.notificationClient = (this.options.notificationsClient = (_d = this.options.notificationsClient) !== null && _d !== void 0 ? _d : new notifications.Notifications(fpaToken, this.options));
+        this.services.syncClient = (this.options.syncClient = (_e = this.options.syncClient) !== null && _e !== void 0 ? _e : new twilioSync.SyncClient(fpaToken, this.options));
+        const configurationOptions = options.Chat || options.IPMessaging || options || {};
+        const region = configurationOptions.region || options.region;
+        const baseUrl = configurationOptions.apiUri
+            || configurationOptions.typingUri
+            || `https://aim.${region || 'us1'}.twilio.com`;
+        this.services.commandExecutor = new commandExecutor.CommandExecutor(baseUrl, { transport: this.options.transport }, productId);
+        const emitFailed = (err) => {
+            this._rejectEnsureReady(err);
+            this.emit('stateChanged', 'failed');
+        };
+        this.services.twilsockClient.once('connectionError', emitFailed);
+        this.services.twilsockClient.once('disconnected', emitFailed);
+        // ConversationsClient will be able to initialize only after twilsock is connected
+        this.services.twilsockClient.once('connected', async () => {
+            log.debug(`ConversationsClient started INITIALIZING`);
+            this.services.twilsockClient.off('connectionError', emitFailed);
+            this.services.twilsockClient.off('disconnected', emitFailed);
+            try {
+                const startupEvent = 'conversations.client.startup';
+                this.services.twilsockClient.addPartialTelemetryEvent(new twilsock.TelemetryEventDescription(startupEvent, 'Conversations client startup', new Date()), startupEvent, twilsock.TelemetryPoint.Start);
+                await this._initialize();
+                this.services.twilsockClient.addPartialTelemetryEvent(new twilsock.TelemetryEventDescription('', '', new Date()), startupEvent, twilsock.TelemetryPoint.End);
+            }
+            catch (err) {
+                // Fail ChatClient if initialization is incomplete
+                this._rejectEnsureReady(err);
+                this.emit('stateChanged', 'failed');
+            }
+        });
+        this._ensureReady = new Promise((resolve, reject) => {
+            this._resolveEnsureReady = resolve;
+            this._rejectEnsureReady = reject;
+        }).catch((err) => { }); // @todo How to process unhandled rejection here?
+        if (startTwilsock) {
+            this.services.twilsockClient.connect();
+        }
+    }
+    static populateInitRegistrations(reg) {
+        reg.populateInitRegistrations([notificationTypes.NotificationTypes.TYPING_INDICATOR]);
+        twilioSync.SyncClient.populateInitRegistrations(reg);
+    }
+    /**
+     * @deprecated Call constructor directly.
+     *
+     * Factory method to create a Conversations client instance.
+     *
+     * The factory method will automatically trigger connection.
+     * Do not use it if you need finer-grained control.
+     *
+     * Since this method returns an already-initialized client, some of the events
+     * will be lost because they happen *before* the initialization. It is
+     * recommended that `client.onWithReplay` is used as opposed to `client.on`
+     * for subscribing to client events. The `client.onWithReplay` will re-emit
+     * the most recent value for a given event if it emitted before the
+     * subscription.
+     *
+     * @param token Access token.
+     * @param options Options to customize the client.
+     * @returns Returns a fully initialized client.
+     */
+    static async create(token, options) {
+        // The logic is as follows:
+        // - If twilsock is not passed in, then the ConversationsClient constructor will call twilsock.connect() by itself
+        //   and we do not need to do it here.
+        // - If twilsock was passed in from the outside, but customer called ConversationsClient.create() then they are
+        //   using an obsolete workflow and the startup sequence will never complete.
+        if (options === null || options === void 0 ? void 0 : options.twilsockClient) {
+            throw new Error('Obsolete usage of ConversationsClient.create() ' +
+                'factory method: if you pass twilsock from the outside then you must ' +
+                'use ConversationsClient constructor and be prepared to work with ' +
+                'uninitialized client.');
+        }
+        const client = new Client_1(token, options);
+        await client._ensureReady;
+        return client;
+    }
+    /**
+     * Information of the logged-in user. Before client initialization, returns an
+     * uninitialized user. Will trigger a {@link Client.userUpdated} event after
+     * initialization.
+     */
+    get user() { return this._myself; }
+    /**
+     * Client reachability state. Throws if accessed before the client
+     * initialization was completed.
+     */
+    get reachabilityEnabled() {
+        if (!this.configuration) {
+            throw new Error('Reachability information could not yet be accessed as the client ' +
+                "has not yet been initialized. Subscribe to the 'stateChanged' event " +
+                'to properly react to the client initialization.');
+        }
+        return this.configuration.reachabilityEnabled;
+    }
+    get token() { return this.fpaToken; }
+    _subscribeToPushNotifications(channelType) {
+        [notificationTypes.NotificationTypes.NEW_MESSAGE,
+            notificationTypes.NotificationTypes.ADDED_TO_CONVERSATION,
+            notificationTypes.NotificationTypes.REMOVED_FROM_CONVERSATION,
+            notificationTypes.NotificationTypes.TYPING_INDICATOR,
+            notificationTypes.NotificationTypes.CONSUMPTION_UPDATE]
+            .forEach(messageType => {
+            this.services.notificationClient.subscribe(channelType, messageType);
+        });
+    }
+    _unsubscribeFromPushNotifications(channelType) {
+        [notificationTypes.NotificationTypes.NEW_MESSAGE,
+            notificationTypes.NotificationTypes.ADDED_TO_CONVERSATION,
+            notificationTypes.NotificationTypes.REMOVED_FROM_CONVERSATION,
+            notificationTypes.NotificationTypes.TYPING_INDICATOR,
+            notificationTypes.NotificationTypes.CONSUMPTION_UPDATE]
+            .forEach(messageType => {
+            this.services.notificationClient.unsubscribe(channelType, messageType);
+        });
+    }
+    async _initialize() {
+        const configurationResponse = await this.services.commandExecutor.fetchResource('Client/v2/Configuration');
+        this.configuration = new configuration.Configuration(this.options, configurationResponse, log);
+        this._myself._resolveInitialization(this.configuration, this.configuration.userIdentity, this.configuration.userInfo, true);
+        this.services.typingIndicator = new typingIndicator.TypingIndicator(this.getConversationBySid.bind(this), this.configuration, this.services);
+        this.services.network = new network.Network(this.configuration, this.services);
+        this.services.users = new users.Users(this._myself, this.configuration, this.services);
+        this.services.users.on('userSubscribed', this.emit.bind(this, 'userSubscribed'));
+        this.services.users.on('userUpdated', (args) => this.emit('userUpdated', args));
+        this.services.users.on('userUnsubscribed', this.emit.bind(this, 'userUnsubscribed'));
+        this.conversations = new conversations.Conversations(this.configuration, this.services);
+        this.conversations.on('conversationAdded', this.emit.bind(this, 'conversationAdded'));
+        this.conversations.on('conversationRemoved', this.emit.bind(this, 'conversationRemoved'));
+        this.conversations.on('conversationJoined', this.emit.bind(this, 'conversationJoined'));
+        this.conversations.on('conversationLeft', this.emit.bind(this, 'conversationLeft'));
+        this.conversations.on('conversationUpdated', (args) => this.emit('conversationUpdated', args));
+        this.conversations.on('participantJoined', this.emit.bind(this, 'participantJoined'));
+        this.conversations.on('participantLeft', this.emit.bind(this, 'participantLeft'));
+        this.conversations.on('participantUpdated', (args) => this.emit('participantUpdated', args));
+        this.conversations.on('messageAdded', this.emit.bind(this, 'messageAdded'));
+        this.conversations.on('messageUpdated', (args) => this.emit('messageUpdated', args));
+        this.conversations.on('messageRemoved', this.emit.bind(this, 'messageRemoved'));
+        this.conversations.on('typingStarted', this.emit.bind(this, 'typingStarted'));
+        this.conversations.on('typingEnded', this.emit.bind(this, 'typingEnded'));
+        this.conversationsPromise = this.conversations.fetchConversations()
+            .then(() => this.conversations)
+            .catch((error) => {
+            throw error;
+        });
+        await this.services.users.myself._ensureFetched();
+        Client_1.supportedPushChannels.forEach(channelType => this._subscribeToPushNotifications(channelType));
+        this.services.typingIndicator.initialize();
+        this.services.mcsClient = new mcsClient.McsClient(this.fpaToken, this.configuration.links.mediaService, this.configuration.links.mediaSetService, Object.assign(Object.assign({}, this.options), { transport: null }));
+        this._resolveEnsureReady();
+        this.emit('stateChanged', 'initialized');
+    }
+    /**
+     * Gracefully shut down the client.
+     */
+    async shutdown() {
+        await this._ensureReady;
+        await this.services.twilsockClient.disconnect();
+    }
+    /**
+     * Update the token used by the client and re-register with the Conversations services.
+     * @param token New access token.
+     */
+    async updateToken(token) {
+        await this._ensureReady;
+        log.info('updateToken');
+        if (this.fpaToken === token) {
+            return this;
+        }
+        await this.services.twilsockClient.updateToken(token);
+        await this.services.notificationClient.updateToken(token);
+        await this.services.mcsClient.updateToken(token);
+        this.fpaToken = token;
+        return this;
+    }
+    /**
+     * Get a known conversation by its SID.
+     * @param conversationSid Conversation sid
+     */
+    async getConversationBySid(conversationSid) {
+        await this._ensureReady;
+        await this.conversations.myConversationsRead.promise;
+        let conversation = await this.conversations.getConversation(conversationSid);
+        if (!conversation) {
+            conversation = await this.conversations.peekConversation(conversationSid);
+        }
+        if (!conversation) {
+            throw new Error(`Conversation with SID ${conversationSid} is not found.`);
+        }
+        return conversation;
+    }
+    /**
+     * Get a known conversation by its unique identifier name.
+     * @param uniqueName The unique identifier name of the conversation.
+     */
+    async getConversationByUniqueName(uniqueName) {
+        await this._ensureReady;
+        await this.conversations.myConversationsRead.promise;
+        const conversation = await this.conversations.getConversationByUniqueName(uniqueName);
+        if (!conversation) {
+            throw new Error(`Conversation with unique name ${uniqueName} is not found.`);
+        }
+        return conversation;
+    }
+    /**
+     * Get the current list of all the subscribed conversations.
+     */
+    async getSubscribedConversations(args) {
+        await this._ensureReady;
+        return this.conversationsPromise.then(conversations => conversations.getConversations(args));
+    }
+    /**
+     * Create a conversation on the server and subscribe to its events.
+     * The default is a conversation with an empty friendly name.
+     * @param options Options for the conversation.
+     */
+    async createConversation(options) {
+        await this._ensureReady;
+        options = options || {};
+        return this.conversationsPromise.then(conversationsEntity => conversationsEntity.addConversation(options));
+    }
+    /**
+     * Register for push notifications.
+     * @param channelType Channel type.
+     * @param registrationId Push notification ID provided by the FCM/APNS service on the platform.
+     */
+    async setPushRegistrationId(channelType, registrationId) {
+        await this._ensureReady;
+        this._subscribeToPushNotifications(channelType);
+        this.services.notificationClient.setPushRegistrationId(channelType, registrationId);
+        await this.services.notificationClient.commitChanges(); // Committing before this point is useless because we have no push id
+    }
+    /**
+     * Unregister from push notifications.
+     * @param channelType Channel type.
+     * @deprecated Use removePushRegistrations() instead.
+     */
+    async unsetPushRegistrationId(channelType) {
+        await this._ensureReady;
+        this._unsubscribeFromPushNotifications(channelType);
+        await this.services.notificationClient.commitChanges();
+    }
+    /**
+     * Clear existing registrations directly using provided device token.
+     * This is useful to ensure stopped subscriptions without resubscribing.
+     *
+     * This function goes completely beside the state machine and removes all registrations.
+     * Use with caution: if it races with current state machine operations, madness will ensue.
+     *
+     * @param channelType Channel type.
+     * @param registrationId Push notification ID provided by the FCM/APNS service on the platform.
+     */
+    async removePushRegistrations(channelType, registrationId) {
+        // do not await this._ensureReady() here - it could be called at any moment
+        await this.services.notificationClient.removeRegistrations(channelType, registrationId);
+    }
+    static parsePushNotificationChatData(data) {
+        const result = {};
+        for (let key in Client_1.supportedPushDataFields) {
+            if (typeof data[key] === 'undefined' || data[key] === null) {
+                continue;
+            }
+            if (key !== 'message_index') {
+                result[Client_1.supportedPushDataFields[key]] = data[key];
+                continue;
+            }
+            if (index.parseToNumber(data[key]) !== null) {
+                result[Client_1.supportedPushDataFields[key]] = Number(data[key]);
+            }
+        }
+        return result;
+    }
+    /**
+     * Static method for push notification payload parsing. Returns parsed push as a {@link PushNotification} object.
+     * @param notificationPayload Push notification payload.
+     */
+    static parsePushNotification(notificationPayload) {
+        log.debug('parsePushNotification, notificationPayload=', notificationPayload);
+        // APNS specifics
+        if (typeof notificationPayload.aps !== 'undefined') {
+            if (!notificationPayload.twi_message_type) {
+                throw new Error('Provided push notification payload does not contain Programmable Chat push notification type');
+            }
+            let data = Client_1.parsePushNotificationChatData(notificationPayload);
+            let apsPayload = notificationPayload.aps;
+            let body = null;
+            let title = null;
+            if (typeof apsPayload.alert === 'string') {
+                body = apsPayload.alert || null;
+            }
+            else {
+                body = apsPayload.alert.body || null;
+                title = apsPayload.alert.title || null;
+            }
+            return new pushNotification.PushNotification({
+                title: title,
+                body: body,
+                sound: apsPayload.sound || null,
+                badge: apsPayload.badge || null,
+                action: apsPayload.category || null,
+                type: notificationPayload.twi_message_type,
+                data: data
+            });
+        }
+        // FCM specifics
+        if (typeof notificationPayload.data !== 'undefined') {
+            let dataPayload = notificationPayload.data;
+            if (!dataPayload.twi_message_type) {
+                throw new Error('Provided push notification payload does not contain Programmable Chat push notification type');
+            }
+            let data = Client_1.parsePushNotificationChatData(notificationPayload.data);
+            return new pushNotification.PushNotification({
+                title: dataPayload.twi_title || null,
+                body: dataPayload.twi_body || null,
+                sound: dataPayload.twi_sound || null,
+                badge: null,
+                action: dataPayload.twi_action || null,
+                type: dataPayload.twi_message_type,
+                data: data
+            });
+        }
+        throw new Error('Provided push notification payload is not Programmable Chat notification');
+    }
+    /**
+     * Handle push notification payload parsing and emit the {@link Client.pushNotification} event on this {@link Client} instance.
+     * @param notificationPayload Push notification payload
+     */
+    async handlePushNotification(notificationPayload) {
+        await this._ensureReady;
+        log.debug('handlePushNotification, notificationPayload=', notificationPayload);
+        this.emit('pushNotification', Client_1.parsePushNotification(notificationPayload));
+    }
+    /**
+     * Gets a user with the given identity. If it's in the subscribed list, then return the user object from it;
+     * if not, then subscribe and add user to the subscribed list.
+     * @param identity Identity of the user.
+     * @returns A fully initialized user.
+     */
+    async getUser(identity) {
+        await this._ensureReady;
+        return this.services.users.getUser(identity);
+    }
+    /**
+     * Get a list of subscribed user objects.
+     */
+    async getSubscribedUsers() {
+        await this._ensureReady;
+        return this.services.users.getSubscribedUsers();
+    }
+};
+/**
+ * Current version of the Conversations client.
+ */
+exports.Client.version = SDK_VERSION;
+exports.Client.supportedPushChannels = ['fcm', 'apn'];
+exports.Client.supportedPushDataFields = {
+    'conversation_sid': 'conversationSid',
+    'message_sid': 'messageSid',
+    'message_index': 'messageIndex'
+};
+/**
+ * Fired when a conversation becomes visible to the client. The event is also triggered when the client creates a new conversation.
+ * Fired for all conversations client has joined.
+ *
+ * Parameters:
+ * 1. {@link Conversation} `conversation` - the conversation in question
+ * @event
+ */
+exports.Client.conversationAdded = 'conversationAdded';
+/**
+ * Fired when the client joins a conversation.
+ *
+ * Parameters:
+ * 1. {@link Conversation} `conversation` - the conversation in question
+ * @event
+ */
+exports.Client.conversationJoined = 'conversationJoined';
+/**
+ * Fired when the client leaves a conversation.
+ *
+ * Parameters:
+ * 1. {@link Conversation} `conversation` - the conversation in question
+ * @event
+ */
+exports.Client.conversationLeft = 'conversationLeft';
+/**
+ * Fired when a conversation is no longer visible to the client.
+ *
+ * Parameters:
+ * 1. {@link Conversation} `conversation` - the conversation in question
+ * @event
+ */
+exports.Client.conversationRemoved = 'conversationRemoved';
+/**
+ * Fired when the attributes or the metadata of a conversation have been updated.
+ * During conversation's creation and initialization, this event might be fired multiple times
+ * for same joined or created conversation as new data is arriving from different sources.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Conversation} `conversation` - the conversation in question
+ *     * {@link ConversationUpdateReason}[] `updateReasons` - array of reasons for the update
+ * @event
+ */
+exports.Client.conversationUpdated = 'conversationUpdated';
+/**
+ * Fired when a participant has joined a conversation.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant in question
+ * @event
+ */
+exports.Client.participantJoined = 'participantJoined';
+/**
+ * Fired when a participant has left a conversation.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant in question
+ * @event
+ */
+exports.Client.participantLeft = 'participantLeft';
+/**
+ * Fired when a participant's fields have been updated.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Participant} `participant` - the participant in question
+ *     * {@link ParticipantUpdateReason}[] `updateReasons` - array of reasons for the update
+ * @event
+ */
+exports.Client.participantUpdated = 'participantUpdated';
+/**
+ * Fired when a new message has been added to the conversation on the server.
+ *
+ * Parameters:
+ * 1. {@link Message} `message` - the message in question
+ * @event
+ */
+exports.Client.messageAdded = 'messageAdded';
+/**
+ * Fired when a message is removed from the message list of a conversation.
+ *
+ * Parameters:
+ * 1. {@link Message} `message` - the message in question
+ * @event
+ */
+exports.Client.messageRemoved = 'messageRemoved';
+/**
+ * Fired when the fields of an existing message are updated with new values.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Message} `message` - the message in question
+ *     * {@link MessageUpdateReason}[] `updateReasons` - array of reasons for the update
+ * @event
+ */
+exports.Client.messageUpdated = 'messageUpdated';
+/**
+ * Fired when the token is about to expire and needs to be updated.
+ * * Parameters:
+ * 1. number `message` - token's time to live
+ * @event
+ */
+exports.Client.tokenAboutToExpire = 'tokenAboutToExpire';
+/**
+ * Fired when the token has expired.
+ * @event
+ */
+exports.Client.tokenExpired = 'tokenExpired';
+/**
+ * Fired when a participant has stopped typing.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant in question
+ * @event
+ */
+exports.Client.typingEnded = 'typingEnded';
+/**
+ * Fired when a participant has started typing.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant in question
+ * @event
+ */
+exports.Client.typingStarted = 'typingStarted';
+/**
+ * Fired when the client has received (and parsed) a push notification via one of the push channels (apn or fcm).
+ *
+ * Parameters:
+ * 1. {@link PushNotification} `pushNotification` - the push notification in question
+ * @event
+ */
+exports.Client.pushNotification = 'pushNotification';
+/**
+ * Fired when the client has subscribed to a user.
+ *
+ * Parameters:
+ * 1. {@link User} `user` - the user in question
+ * @event
+ */
+exports.Client.userSubscribed = 'userSubscribed';
+/**
+ * Fired when the client has unsubscribed from a user.
+ *
+ * Parameters:
+ * 1. {@link User} `user` - the user in question
+ * @event
+ */
+exports.Client.userUnsubscribed = 'userUnsubscribed';
+/**
+ * Fired when the properties or the reachability status of a user have been updated.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link User} `user` - the user in question
+ *     * {@link UserUpdateReason}[] `updateReasons` - array of reasons for the update
+ * @event
+ */
+exports.Client.userUpdated = 'userUpdated';
+/**
+ * Fired when the state of the client has been changed.
+ *
+ * Parameters:
+ * 1. {@link State} `state` - the new client state
+ * @event
+ */
+exports.Client.stateChanged = 'stateChanged';
+/**
+ * Fired when the connection state of the client has been changed.
+ *
+ * Paremeters:
+ * 1. {@link ConnectionState} `state` - the new connection state
+ * @event
+ */
+exports.Client.connectionStateChanged = 'connectionStateChanged';
+/**
+ * Fired when the connection is interrupted for an unexpected reason.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * boolean `terminal` - Twilsock will stop connection attempts if true
+ *     * string `message` - the error message of the root cause
+ *     * number? `httpStatusCode` - http status code if available
+ *     * number? `errorCode` - Twilio public error code if available
+ * @event
+ */
+exports.Client.connectionError = 'connectionError';
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "updateToken", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "getConversationBySid", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "getConversationByUniqueName", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync([
+        'undefined',
+        declarativeTypeValidator.objectSchema('conversation options', {
+            friendlyName: ['string', 'undefined'],
+            isPrivate: ['boolean', 'undefined'],
+            uniqueName: ['string', 'undefined']
+        })
+    ]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "createConversation", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.literal('fcm', 'apn'), 'string'),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String, String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "setPushRegistrationId", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.literal('fcm', 'apn')),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "unsetPushRegistrationId", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.literal('fcm', 'apn'), declarativeTypeValidator.nonEmptyString),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String, String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "removePushRegistrations", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.pureObject),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "handlePushNotification", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client.prototype, "getUser", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync('string', ['undefined', declarativeTypeValidator.pureObject]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String, Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], exports.Client, "create", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypes(declarativeTypeValidator.pureObject),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object]),
+    tslib_es6.__metadata("design:returntype", pushNotification.PushNotification)
+], exports.Client, "parsePushNotification", null);
+exports.Client = Client_1 = tslib_es6.__decorate([
+    declarativeTypeValidator.validateConstructorTypes(declarativeTypeValidator.nonEmptyString, [
+        declarativeTypeValidator.pureObject,
+        'undefined'
+    ]),
+    tslib_es6.__metadata("design:paramtypes", [String, Object])
+], exports.Client);
+//# sourceMappingURL=client.js.map