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

package/dist/conversation.js

@@ -0,0 +1,973 @@
+/*
+@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 participants = require('./data/participants.js');
+var participant = require('./participant.js');
+var messages = require('./data/messages.js');
+var index = require('./util/index.js');
+var declarativeTypeValidator = require('@twilio/declarative-type-validator');
+var messageBuilder = require('./message-builder.js');
+var replayEventEmitter = require('@twilio/replay-event-emitter');
+var isEqual = require('lodash.isequal');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
+
+const log = logger.Logger.scope('Conversation');
+const fieldMappings = {
+    lastMessage: 'lastMessage',
+    attributes: 'attributes',
+    createdBy: 'createdBy',
+    dateCreated: 'dateCreated',
+    dateUpdated: 'dateUpdated',
+    friendlyName: 'friendlyName',
+    lastConsumedMessageIndex: 'lastConsumedMessageIndex',
+    notificationLevel: 'notificationLevel',
+    sid: 'sid',
+    status: 'status',
+    uniqueName: 'uniqueName',
+    state: 'state'
+};
+function parseTime(timeString) {
+    try {
+        return new Date(timeString);
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * A conversation represents communication between multiple Conversations clients
+ */
+class Conversation extends replayEventEmitter.ReplayEventEmitter {
+    /**
+     * @internal
+     */
+    constructor(descriptor, sid, links, configuration, services) {
+        super();
+        this.sid = sid;
+        this.links = links;
+        this.configuration = configuration;
+        this.services = services;
+        let attributes = descriptor.attributes || {};
+        let createdBy = descriptor.createdBy;
+        let dateCreated = parseTime(descriptor.dateCreated);
+        let dateUpdated = parseTime(descriptor.dateUpdated);
+        let friendlyName = descriptor.friendlyName || null;
+        let lastReadMessageIndex = Number.isInteger(descriptor.lastConsumedMessageIndex) ? descriptor.lastConsumedMessageIndex : null;
+        let uniqueName = descriptor.uniqueName || null;
+        try {
+            JSON.stringify(attributes);
+        }
+        catch (e) {
+            throw new Error('Attributes must be a valid JSON object.');
+        }
+        this.entityName = descriptor.channel;
+        this.channelState = {
+            uniqueName,
+            status: 'notParticipating',
+            attributes,
+            createdBy,
+            dateCreated,
+            dateUpdated,
+            friendlyName,
+            lastReadMessageIndex: lastReadMessageIndex
+        };
+        if (descriptor.notificationLevel) {
+            this.channelState.notificationLevel = descriptor.notificationLevel;
+        }
+        const participantsLinks = {
+            participants: this.links.participants
+        };
+        this.participants = new Map();
+        this.participantsEntity = new participants.Participants(this, this.participants, participantsLinks, this.configuration, this.services);
+        this.participantsEntity.on('participantJoined', this.emit.bind(this, 'participantJoined'));
+        this.participantsEntity.on('participantLeft', this.emit.bind(this, 'participantLeft'));
+        this.participantsEntity.on('participantUpdated', (args) => this.emit('participantUpdated', args));
+        this.messagesEntity = new messages.Messages(this, configuration, services);
+        this.messagesEntity.on('messageAdded', message => this._onMessageAdded(message));
+        this.messagesEntity.on('messageUpdated', (args) => this.emit('messageUpdated', args));
+        this.messagesEntity.on('messageRemoved', this.emit.bind(this, 'messageRemoved'));
+    }
+    /**
+     * Unique name of the conversation.
+     */
+    get uniqueName() { return this.channelState.uniqueName; }
+    /**
+     * Status of the conversation.
+     */
+    get status() { return this.channelState.status; }
+    /**
+     * Name of the conversation.
+     */
+    get friendlyName() { return this.channelState.friendlyName; }
+    /**
+     * Date this conversation was last updated on.
+     */
+    get dateUpdated() { return this.channelState.dateUpdated; }
+    /**
+     * Date this conversation was created on.
+     */
+    get dateCreated() { return this.channelState.dateCreated; }
+    /**
+     * Identity of the user that created this conversation.
+     */
+    get createdBy() { return this.channelState.createdBy; }
+    /**
+     * Custom attributes of the conversation.
+     */
+    get attributes() { return this.channelState.attributes; }
+    /**
+     * Index of the last message the user has read in this conversation.
+     */
+    get lastReadMessageIndex() { return this.channelState.lastReadMessageIndex; }
+    /**
+     * Last message sent to this conversation.
+     */
+    get lastMessage() { return this.channelState.lastMessage; }
+    /**
+     * User notification level for this conversation.
+     */
+    get notificationLevel() { return this.channelState.notificationLevel; }
+    get limits() { return this.configuration.limits; }
+    /**
+     * State of the conversation.
+     */
+    get state() { return this.channelState.state; }
+    /**
+     * Load and subscribe to this conversation and do not subscribe to its participants and messages.
+     * This or _subscribeStreams will need to be called before any events on conversation will fire.
+     * @internal
+     */
+    _subscribe() {
+        var _a;
+        return this.entityPromise = (_a = this.entityPromise) !== null && _a !== void 0 ? _a : this.services.syncClient.document({ id: this.entityName, mode: 'open_existing' })
+            .then(entity => {
+            this.entity = entity;
+            this.entity.on('updated', args => { this._update(args.data); });
+            this.entity.on('removed', () => this.emit('removed', this));
+            this._update(this.entity.data);
+            return entity;
+        })
+            .catch(err => {
+            this.entity = null;
+            this.entityPromise = null;
+            if (this.services.syncClient.connectionState != 'disconnected') {
+                log.error('Failed to get conversation object', err);
+            }
+            log.debug('ERROR: Failed to get conversation object', err);
+            throw err;
+        });
+    }
+    /**
+     * Load the attributes of this conversation and instantiate its participants and messages.
+     * This or _subscribe will need to be called before any events on the conversation will fire.
+     * This will need to be called before any events on participants or messages will fire
+     * @internal
+     */
+    async _subscribeStreams() {
+        try {
+            await this._subscribe();
+            log.trace('_subscribeStreams, this.entity.data=', this.entity.data);
+            const messagesObjectName = this.entity.data.messages;
+            const rosterObjectName = this.entity.data.roster;
+            await Promise.all([
+                this.messagesEntity.subscribe(messagesObjectName),
+                this.participantsEntity.subscribe(rosterObjectName)
+            ]);
+        }
+        catch (err) {
+            if (this.services.syncClient.connectionState !== 'disconnected') {
+                log.error('Failed to subscribe on conversation objects', this.sid, err);
+            }
+            log.debug('ERROR: Failed to subscribe on conversation objects', this.sid, err);
+            throw err;
+        }
+    }
+    /**
+     * Stop listening for and firing events on this conversation.
+     * @internal
+     */
+    async _unsubscribe() {
+        if (this.entity) {
+            await this.entity.close();
+            this.entity = null;
+            this.entityPromise = null;
+        }
+        return Promise.all([
+            this.participantsEntity.unsubscribe(),
+            this.messagesEntity.unsubscribe()
+        ]);
+    }
+    /**
+     * Set conversation status.
+     * @internal
+     */
+    _setStatus(status, source) {
+        this.statusSource = source;
+        if (this.channelState.status === status) {
+            return;
+        }
+        this.channelState.status = status;
+        if (status === 'joined') {
+            this._subscribeStreams()
+                .catch(err => {
+                log.debug('ERROR while setting conversation status ' + status, err);
+                if (this.services.syncClient.connectionState !== 'disconnected') {
+                    throw err;
+                }
+            });
+        }
+        else if (this.entityPromise) {
+            this._unsubscribe().catch(err => {
+                log.debug('ERROR while setting conversation status ' + status, err);
+                if (this.services.syncClient.connectionState !== 'disconnected') {
+                    throw err;
+                }
+            });
+        }
+    }
+    /**
+     * Get the source of the conversation update.
+     * @internal
+     */
+    _statusSource() {
+        return this.statusSource;
+    }
+    static preprocessUpdate(update, conversationSid) {
+        try {
+            if (typeof update.attributes === 'string') {
+                update.attributes = JSON.parse(update.attributes);
+            }
+            else if (update.attributes) {
+                JSON.stringify(update.attributes);
+            }
+        }
+        catch (e) {
+            log.warn('Retrieved malformed attributes from the server for conversation: ' + conversationSid);
+            update.attributes = {};
+        }
+        try {
+            if (update.dateCreated) {
+                update.dateCreated = new Date(update.dateCreated);
+            }
+        }
+        catch (e) {
+            log.warn('Retrieved malformed dateCreated from the server for conversation: ' + conversationSid);
+            delete update.dateCreated;
+        }
+        try {
+            if (update.dateUpdated) {
+                update.dateUpdated = new Date(update.dateUpdated);
+            }
+        }
+        catch (e) {
+            log.warn('Retrieved malformed dateUpdated from the server for conversation: ' + conversationSid);
+            delete update.dateUpdated;
+        }
+        try {
+            if (update.lastMessage && update.lastMessage.timestamp) {
+                update.lastMessage.timestamp = new Date(update.lastMessage.timestamp);
+            }
+        }
+        catch (e) {
+            log.warn('Retrieved malformed lastMessage.timestamp from the server for conversation: ' + conversationSid);
+            delete update.lastMessage.timestamp;
+        }
+    }
+    /**
+     * Update the local conversation object with new values.
+     * @internal
+     */
+    _update(update) {
+        var _a, _b, _c, _d, _e;
+        log.trace('_update', update);
+        Conversation.preprocessUpdate(update, this.sid);
+        const updateReasons = new Set();
+        for (const key of Object.keys(update)) {
+            const localKey = fieldMappings[key];
+            if (!localKey) {
+                continue;
+            }
+            switch (localKey) {
+                case fieldMappings.status:
+                    if (!update.status || update.status === 'unknown'
+                        || this.channelState.status === update.status) {
+                        break;
+                    }
+                    this.channelState.status = update.status;
+                    updateReasons.add(localKey);
+                    break;
+                case fieldMappings.attributes:
+                    if (isEqual__default['default'](this.channelState.attributes, update.attributes)) {
+                        break;
+                    }
+                    this.channelState.attributes = update.attributes;
+                    updateReasons.add(localKey);
+                    break;
+                case fieldMappings.lastConsumedMessageIndex:
+                    if (update.lastConsumedMessageIndex === undefined
+                        || update.lastConsumedMessageIndex === this.channelState.lastReadMessageIndex) {
+                        break;
+                    }
+                    this.channelState.lastReadMessageIndex = update.lastConsumedMessageIndex;
+                    updateReasons.add('lastReadMessageIndex');
+                    break;
+                case fieldMappings.lastMessage:
+                    if (this.channelState.lastMessage && !update.lastMessage) {
+                        delete this.channelState.lastMessage;
+                        updateReasons.add(localKey);
+                        break;
+                    }
+                    this.channelState.lastMessage = this.channelState.lastMessage || {};
+                    if (((_a = update.lastMessage) === null || _a === void 0 ? void 0 : _a.index) !== undefined
+                        && update.lastMessage.index !== this.channelState.lastMessage.index) {
+                        this.channelState.lastMessage.index = update.lastMessage.index;
+                        updateReasons.add(localKey);
+                    }
+                    if (((_b = update.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp) !== undefined
+                        && ((_d = (_c = this.channelState.lastMessage) === null || _c === void 0 ? void 0 : _c.dateCreated) === null || _d === void 0 ? void 0 : _d.getTime()) !== update.lastMessage.timestamp.getTime()) {
+                        this.channelState.lastMessage.dateCreated = update.lastMessage.timestamp;
+                        updateReasons.add(localKey);
+                    }
+                    if (isEqual__default['default'](this.channelState.lastMessage, {})) {
+                        delete this.channelState.lastMessage;
+                    }
+                    break;
+                case fieldMappings.state:
+                    const state = update.state || undefined;
+                    if (state !== undefined) {
+                        state.dateUpdated = new Date(state.dateUpdated);
+                    }
+                    if (isEqual__default['default'](this.channelState.state, state)) {
+                        break;
+                    }
+                    this.channelState.state = state;
+                    updateReasons.add(localKey);
+                    break;
+                default:
+                    const isDate = update[key] instanceof Date;
+                    const keysMatchAsDates = isDate && ((_e = this.channelState[localKey]) === null || _e === void 0 ? void 0 : _e.getTime()) === update[key].getTime();
+                    const keysMatchAsNonDates = !isDate && this[localKey] === update[key];
+                    if (keysMatchAsDates || keysMatchAsNonDates) {
+                        break;
+                    }
+                    this.channelState[localKey] = update[key];
+                    updateReasons.add(localKey);
+            }
+        }
+        if (updateReasons.size > 0) {
+            this.emit('updated', { conversation: this, updateReasons: [...updateReasons] });
+        }
+    }
+    /**
+     * @internal
+     */
+    _onMessageAdded(message) {
+        for (let participant of this.participants.values()) {
+            if (participant.identity === message.author) {
+                participant._endTyping();
+                break;
+            }
+        }
+        this.emit('messageAdded', message);
+    }
+    async _setLastReadMessageIndex(index) {
+        const result = await this.services.commandExecutor.mutateResource('post', `${this.configuration.links.myConversations}/${this.sid}`, {
+            last_read_message_index: index
+        });
+        return result.unread_messages_count;
+    }
+    /**
+     * Add a participant to the conversation by its identity.
+     * @param identity Identity of the Client to add.
+     * @param attributes Attributes to be attached to the participant.
+     */
+    async add(identity, attributes) {
+        return this.participantsEntity.add(identity, attributes);
+    }
+    /**
+     * Add a non-chat participant to the conversation.
+     * @param proxyAddress Proxy (Twilio) address of the participant.
+     * @param address User address of the participant.
+     * @param attributes Attributes to be attached to the participant.
+     */
+    async addNonChatParticipant(proxyAddress, address, attributes) {
+        return this.participantsEntity.addNonChatParticipant(proxyAddress, address, attributes);
+    }
+    /**
+     * Advance the conversation's last read message index to the current read horizon.
+     * Rejects if the user is not a participant of the conversation.
+     * Last read message index is updated only if the new index value is higher than the previous.
+     * @param index Message index to advance to.
+     * @return Resulting unread messages count in the conversation.
+     */
+    async advanceLastReadMessageIndex(index) {
+        await this._subscribeStreams();
+        if (index < this.lastReadMessageIndex) {
+            return await this._setLastReadMessageIndex(this.lastReadMessageIndex);
+        }
+        return await this._setLastReadMessageIndex(index);
+    }
+    /**
+     * Delete the conversation and unsubscribe from its events.
+     */
+    async delete() {
+        await this.services.commandExecutor.mutateResource('delete', this.links.self);
+        return this;
+    }
+    /**
+     * Get the custom attributes of this Conversation.
+     */
+    async getAttributes() {
+        await this._subscribe();
+        return this.attributes;
+    }
+    /**
+     * Returns messages from the conversation using the paginator interface.
+     * @param pageSize Number of messages to return in a single chunk. Default is 30.
+     * @param anchor Index of the newest message to fetch. Default is from the end.
+     * @param direction Query direction. By default it queries backwards
+     * from newer to older. The `"forward"` value will query in the opposite direction.
+     * @return A page of messages.
+     */
+    async getMessages(pageSize, anchor, direction) {
+        await this._subscribeStreams();
+        return this.messagesEntity.getMessages(pageSize, anchor, direction);
+    }
+    /**
+     * Get a list of all the participants who are joined to this conversation.
+     */
+    async getParticipants() {
+        await this._subscribeStreams();
+        return this.participantsEntity.getParticipants();
+    }
+    /**
+     * Get conversation participants count.
+     *
+     * This method is semi-realtime. This means that this data will be eventually correct,
+     * but will also be possibly incorrect for a few seconds. The Conversations system does not
+     * provide real time events for counter values changes.
+     *
+     * This is useful for any UI badges, but it is not recommended to build any core application
+     * logic based on these counters being accurate in real time.
+     */
+    async getParticipantsCount() {
+        const url = new index.UriBuilder(this.configuration.links.conversations)
+            .path(this.sid)
+            .build();
+        const response = await this.services.network.get(url);
+        return response.body.participants_count;
+    }
+    /**
+     * Get a participant by its SID.
+     * @param participantSid Participant SID.
+     */
+    async getParticipantBySid(participantSid) {
+        return this.participantsEntity.getParticipantBySid(participantSid);
+    }
+    /**
+     * Get a participant by its identity.
+     * @param identity Participant identity.
+     */
+    async getParticipantByIdentity(identity) {
+        return this.participantsEntity.getParticipantByIdentity(identity);
+    }
+    /**
+     * Get the total message count in the conversation.
+     *
+     * This method is semi-realtime. This means that this data will be eventually correct,
+     * but will also be possibly incorrect for a few seconds. The Conversations system does not
+     * provide real time events for counter values changes.
+     *
+     * This is useful for any UI badges, but it is not recommended to build any core application
+     * logic based on these counters being accurate in real time.
+     */
+    async getMessagesCount() {
+        const url = new index.UriBuilder(this.configuration.links.conversations)
+            .path(this.sid)
+            .build();
+        const response = await this.services.network.get(url);
+        return response.body.messages_count;
+    }
+    /**
+     * Get unread messages count for the user if they are a participant of this conversation.
+     * Rejects if the user is not a participant of the conversation.
+     *
+     * Use this method to obtain the number of unread messages together with
+     * {@link Conversation.updateLastReadMessageIndex} instead of relying on the
+     * message indices which may have gaps. See {@link Message.index} for details.
+     *
+     * This method is semi-realtime. This means that this data will be eventually correct,
+     * but will also be possibly incorrect for a few seconds. The Conversations system does not
+     * provide real time events for counter values changes.
+     *
+     * This is useful for any UI badges, but it is not recommended to build any core application
+     * logic based on these counters being accurate in real time.
+     */
+    async getUnreadMessagesCount() {
+        const url = new index.UriBuilder(this.configuration.links.myConversations)
+            .path(this.sid)
+            .build();
+        const response = await this.services.network.get(url);
+        if (response.body.conversation_sid !== this.sid) {
+            throw new Error('Conversation was not found in the user conversations list');
+        }
+        const unreadMessageCount = response.body.unread_messages_count;
+        if (typeof unreadMessageCount === 'number') {
+            return unreadMessageCount;
+        }
+        return null;
+    }
+    /**
+     * Join the conversation and subscribe to its events.
+     */
+    async join() {
+        await this.services.commandExecutor.mutateResource('post', this.links.participants, {
+            identity: this.configuration.userIdentity
+        });
+        return this;
+    }
+    /**
+     * Leave the conversation.
+     */
+    async leave() {
+        if (this.channelState.status === 'joined') {
+            await this.services.commandExecutor.mutateResource('delete', `${this.links.participants}/${this.configuration.userIdentity}`);
+        }
+        return this;
+    }
+    /**
+     * Remove a participant from the conversation. When a string is passed as the
+     * argument, it will assume that the string is an identity or SID.
+     * @param participant Identity, SID or the participant object to remove.
+     */
+    async removeParticipant(participant) {
+        await this.participantsEntity.remove(typeof participant === 'string'
+            ? participant
+            : participant.sid);
+    }
+    /**
+     * Send a message to the conversation.
+     * @param message Message body for the text message,
+     * `FormData` or {@link SendMediaOptions} for media content. Sending FormData is supported only with the browser engine.
+     * @param messageAttributes Attributes for the message.
+     * @param emailOptions Email options for the message.
+     * @return Index of the new message.
+     */
+    async sendMessage(message, messageAttributes, emailOptions) {
+        if (typeof message === 'string' || message === null) {
+            let response = await this.messagesEntity.send(message, messageAttributes, emailOptions);
+            return index.parseToNumber(response.index);
+        }
+        let response = await this.messagesEntity.sendMedia(message, messageAttributes, emailOptions);
+        return index.parseToNumber(response.index);
+    }
+    /**
+     * New interface to prepare for sending a message.
+     * Use instead of `sendMessage`.
+     */
+    prepareMessage() {
+        return new messageBuilder.MessageBuilder(this.limits, this.messagesEntity);
+    }
+    /**
+     * Set last read message index of the conversation to the index of the last known message.
+     * @return Resulting unread messages count in the conversation.
+     */
+    async setAllMessagesRead() {
+        await this._subscribeStreams();
+        let messagesPage = await this.getMessages(1);
+        if (messagesPage.items.length > 0) {
+            return this.advanceLastReadMessageIndex(messagesPage.items[0].index);
+        }
+        return Promise.resolve(0);
+    }
+    /**
+     * Set all messages in the conversation unread.
+     * @return Resulting unread messages count in the conversation.
+     */
+    async setAllMessagesUnread() {
+        await this._subscribeStreams();
+        return await this._setLastReadMessageIndex(null);
+    }
+    /**
+     * Set user notification level for this conversation.
+     * @param notificationLevel New user notification level.
+     */
+    async setUserNotificationLevel(notificationLevel) {
+        await this.services.commandExecutor.mutateResource('post', `${this.configuration.links.myConversations}/${this.sid}`, {
+            notification_level: notificationLevel
+        });
+    }
+    /**
+     * Send a notification to the server indicating that this client is currently typing in this conversation.
+     * Typing ended notification is sent after a while automatically, but by calling this method again you ensure that typing ended is not received.
+     */
+    typing() {
+        return this.services.typingIndicator.send(this.sid);
+    }
+    /**
+     * Update the attributes of the conversation.
+     * @param attributes New attributes.
+     */
+    async updateAttributes(attributes) {
+        await this.services.commandExecutor.mutateResource('post', this.links.self, {
+            attributes: attributes !== undefined ? JSON.stringify(attributes) : undefined
+        });
+        return this;
+    }
+    /**
+     * Update the friendly name of the conversation.
+     * @param friendlyName New friendly name.
+     */
+    async updateFriendlyName(friendlyName) {
+        if (this.channelState.friendlyName !== friendlyName) {
+            await this.services.commandExecutor.mutateResource('post', this.links.self, { friendly_name: friendlyName });
+        }
+        return this;
+    }
+    /**
+     * Set the last read message index to the current read horizon.
+     * @param index Message index to set as last read.
+     * If null is provided, then the behavior is identical to {@link Conversation.setAllMessagesUnread}.
+     * @returns Resulting unread messages count in the conversation.
+     */
+    async updateLastReadMessageIndex(index) {
+        await this._subscribeStreams();
+        return this._setLastReadMessageIndex(index);
+    }
+    /**
+     * Update the unique name of the conversation.
+     * @param uniqueName New unique name for the conversation. Setting unique name to null removes it.
+     */
+    async updateUniqueName(uniqueName) {
+        if (this.channelState.uniqueName !== uniqueName) {
+            if (!uniqueName) {
+                uniqueName = '';
+            }
+            await this.services.commandExecutor.mutateResource('post', this.links.self, {
+                unique_name: uniqueName
+            });
+        }
+        return this;
+    }
+}
+/**
+ * Fired when a participant has joined the conversation.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - participant that joined the conversation
+ * @event
+ */
+Conversation.participantJoined = 'participantJoined';
+/**
+ * Fired when a participant has left the conversation.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - participant that left the conversation
+ * @event
+ */
+Conversation.participantLeft = 'participantLeft';
+/**
+ * Fired when data of a participant has been updated.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Participant} `participant` - participant that has received the update
+ *     * {@link ParticipantUpdateReason}[] `updateReasons` - array of reasons for update
+ * @event
+ */
+Conversation.participantUpdated = 'participantUpdated';
+/**
+ * Fired when a new message has been added to the conversation.
+ *
+ * Parameters:
+ * 1. {@link Message} `message` - message that has been added
+ * @event
+ */
+Conversation.messageAdded = 'messageAdded';
+/**
+ * Fired when message is removed from the conversation's message list.
+ *
+ * Parameters:
+ * 1. {@link Message} `message` - message that has been removed
+ * @event
+ */
+Conversation.messageRemoved = 'messageRemoved';
+/**
+ * Fired when data of a message has been updated.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Message} `message` - message that has received the update
+ *     * {@link MessageUpdateReason}[] `updateReasons` - array of reasons for update
+ * @event
+ */
+Conversation.messageUpdated = 'messageUpdated';
+/**
+ * Fired when a participant has stopped typing.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant that has stopped typing
+ * @event
+ */
+Conversation.typingEnded = 'typingEnded';
+/**
+ * Fired when a participant has started typing.
+ *
+ * Parameters:
+ * 1. {@link Participant} `participant` - the participant that has started typing
+ * @event
+ */
+Conversation.typingStarted = 'typingStarted';
+/**
+ * Fired when the data of the conversation has been updated.
+ *
+ * Parameters:
+ * 1. object `data` - info object provided with the event. It has the following properties:
+ *     * {@link Conversation} `conversation` - conversation that has received the update
+ *     * {@link ConversationUpdateReason}[] `updateReasons` - array of reasons for update
+ * @event
+ */
+Conversation.updated = 'updated';
+/**
+ * Fired when the conversation was destroyed or the currently-logged-in user has left private conversation.
+ *
+ * Parameters:
+ * 1. {@link Conversation} `conversation` - conversation that has been removed
+ * @event
+ */
+Conversation.removed = 'removed';
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString, ['undefined', 'string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String, Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "add", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString, declarativeTypeValidator.nonEmptyString, ['undefined', 'string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String, String, Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "addNonChatParticipant", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonNegativeInteger),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Number]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "advanceLastReadMessageIndex", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(['undefined', declarativeTypeValidator.nonNegativeInteger], ['undefined', declarativeTypeValidator.nonNegativeInteger], ['undefined', declarativeTypeValidator.literal('backwards', 'forward')]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Number, Number, String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "getMessages", 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)
+], Conversation.prototype, "getParticipantBySid", 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)
+], Conversation.prototype, "getParticipantByIdentity", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync([declarativeTypeValidator.nonEmptyString, participant.Participant]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "removeParticipant", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync([
+        'string',
+        declarativeTypeValidator.literal(null),
+        // Wrapping it into a custom rule is necessary because the FormData class is not available on initialization.
+        declarativeTypeValidator.custom((value) => [value instanceof FormData, 'an instance of FormData']),
+        declarativeTypeValidator.objectSchema('media options', {
+            contentType: declarativeTypeValidator.nonEmptyString,
+            media: declarativeTypeValidator.custom((value) => {
+                let isValid = (typeof value === 'string' && value.length > 0) || value instanceof Uint8Array || value instanceof ArrayBuffer;
+                if (typeof Blob === 'function') {
+                    isValid = isValid || value instanceof Blob;
+                }
+                return [
+                    isValid,
+                    'a non-empty string, an instance of Buffer or an instance of Blob'
+                ];
+            })
+        })
+    ], ['undefined', 'string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)], ['undefined', declarativeTypeValidator.literal(null), declarativeTypeValidator.objectSchema('email attributes', {
+            subject: [declarativeTypeValidator.nonEmptyString, 'undefined']
+        })]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object, Object, Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "sendMessage", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.literal('default', 'muted')),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "setUserNotificationLevel", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(['string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Object]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "updateAttributes", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(['string']),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "updateFriendlyName", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync([declarativeTypeValidator.literal(null), declarativeTypeValidator.nonNegativeInteger]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [Number]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "updateLastReadMessageIndex", null);
+tslib_es6.__decorate([
+    declarativeTypeValidator.validateTypesAsync(['string', declarativeTypeValidator.literal(null)]),
+    tslib_es6.__metadata("design:type", Function),
+    tslib_es6.__metadata("design:paramtypes", [String]),
+    tslib_es6.__metadata("design:returntype", Promise)
+], Conversation.prototype, "updateUniqueName", null);
+
+exports.Conversation = Conversation;
+//# sourceMappingURL=conversation.js.map