@twilio/conversations 3.0.0-rc.1 → 3.0.0-rc.5

package/dist/conversation.js

@@ -131,6 +131,7 @@ This software includes platform.js under the following license.
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var tslib_es6 = require('./node_modules/tslib/tslib.es6.js');
+require('isomorphic-form-data');
 var logger = require('./logger.js');
 var participants = require('./data/participants.js');
 var participant = require('./participant.js');
@@ -146,7 +147,9 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var isEqual__default = /*#__PURE__*/_interopDefaultLegacy(isEqual);
 
-const log = logger.Logger.scope("Conversation");
+/**
+ * Map of the fields that will be processed with update messages.
+ */
 const fieldMappings = {
     lastMessage: "lastMessage",
     attributes: "attributes",
@@ -162,255 +165,150 @@ const fieldMappings = {
     state: "state",
     bindings: "bindings",
 };
-function parseTime(timeString) {
-    try {
-        return new Date(timeString);
-    }
-    catch (e) {
-        return null;
-    }
-}
 /**
- * A conversation represents communication between multiple Conversations clients
+ * A conversation represents communication between multiple Conversations
+ * clients.
  */
 class Conversation extends replayEventEmitter.ReplayEventEmitter {
     /**
+     * @param descriptor Conversation descriptor.
+     * @param sid Conversation SID.
+     * @param links Conversation links for REST requests.
+     * @param configuration Client configuration.
+     * @param services Conversation services.
      * @internal
      */
     constructor(descriptor, sid, links, configuration, services) {
-        var _a;
+        var _a, _b;
         super();
         this.sid = sid;
-        this.links = links;
-        this.configuration = configuration;
-        this.services = services;
-        const attributes = descriptor.attributes || {};
-        const createdBy = descriptor.createdBy;
-        const dateCreated = parseTime(descriptor.dateCreated);
-        const dateUpdated = parseTime(descriptor.dateUpdated);
-        const friendlyName = descriptor.friendlyName || null;
-        const lastReadMessageIndex = Number.isInteger(descriptor.lastConsumedMessageIndex)
-            ? descriptor.lastConsumedMessageIndex
-            : null;
-        const 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,
+        this._links = links;
+        this._configuration = configuration;
+        this._services = services;
+        this._entityName = descriptor.channel;
+        this._internalState = {
+            uniqueName: descriptor.uniqueName || null,
             status: "notParticipating",
-            attributes,
-            createdBy,
-            dateCreated,
-            dateUpdated,
-            friendlyName,
-            lastReadMessageIndex,
-            bindings: (_a = descriptor.bindings) !== null && _a !== void 0 ? _a : {},
+            attributes: (_a = descriptor.attributes) !== null && _a !== void 0 ? _a : {},
+            createdBy: descriptor.createdBy,
+            dateCreated: index.parseTime(descriptor.dateCreated),
+            dateUpdated: index.parseTime(descriptor.dateUpdated),
+            friendlyName: descriptor.friendlyName || null,
+            lastReadMessageIndex: Number.isInteger(descriptor.lastConsumedMessageIndex)
+                ? descriptor.lastConsumedMessageIndex
+                : null,
+            bindings: (_b = descriptor.bindings) !== null && _b !== void 0 ? _b : {},
         };
         if (descriptor.notificationLevel) {
-            this.channelState.notificationLevel = descriptor.notificationLevel;
+            this._internalState.notificationLevel = descriptor.notificationLevel;
         }
         const participantsLinks = {
-            participants: this.links.participants,
+            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", (participant) => this.emit("participantJoined", participant));
-        this.participantsEntity.on("participantLeft", (participant) => this.emit("participantLeft", participant));
-        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", (message) => this.emit("messageRemoved", message));
+        this._participants = new Map();
+        this._participantsEntity = new participants.Participants(this, this._participants, participantsLinks, this._configuration, this._services);
+        this._participantsEntity.on("participantJoined", (participant) => this.emit("participantJoined", participant));
+        this._participantsEntity.on("participantLeft", (participant) => this.emit("participantLeft", participant));
+        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", (message) => this.emit("messageRemoved", message));
     }
     /**
      * Unique name of the conversation.
      */
     get uniqueName() {
-        return this.channelState.uniqueName;
+        return this._internalState.uniqueName;
     }
     /**
      * Status of the conversation.
      */
     get status() {
-        return this.channelState.status;
+        return this._internalState.status;
     }
     /**
      * Name of the conversation.
      */
     get friendlyName() {
-        return this.channelState.friendlyName;
+        return this._internalState.friendlyName;
     }
     /**
      * Date this conversation was last updated on.
      */
     get dateUpdated() {
-        return this.channelState.dateUpdated;
+        return this._internalState.dateUpdated;
     }
     /**
      * Date this conversation was created on.
      */
     get dateCreated() {
-        return this.channelState.dateCreated;
+        return this._internalState.dateCreated;
     }
     /**
      * Identity of the user that created this conversation.
      */
     get createdBy() {
         var _a;
-        return (_a = this.channelState.createdBy) !== null && _a !== void 0 ? _a : "";
+        return (_a = this._internalState.createdBy) !== null && _a !== void 0 ? _a : "";
     }
     /**
      * Custom attributes of the conversation.
      */
     get attributes() {
-        return this.channelState.attributes;
+        return this._internalState.attributes;
     }
     /**
      * Index of the last message the user has read in this conversation.
      */
     get lastReadMessageIndex() {
-        return this.channelState.lastReadMessageIndex;
+        return this._internalState.lastReadMessageIndex;
     }
     /**
      * Last message sent to this conversation.
      */
     get lastMessage() {
         var _a;
-        return (_a = this.channelState.lastMessage) !== null && _a !== void 0 ? _a : undefined;
+        return (_a = this._internalState.lastMessage) !== null && _a !== void 0 ? _a : undefined;
     }
     /**
      * User notification level for this conversation.
      */
     get notificationLevel() {
         var _a;
-        return (_a = this.channelState.notificationLevel) !== null && _a !== void 0 ? _a : "default";
+        return (_a = this._internalState.notificationLevel) !== null && _a !== void 0 ? _a : "default";
     }
+    /**
+     * Conversation bindings. Undocumented feature (for now).
+     * @internal
+     */
     get bindings() {
-        return this.channelState.bindings;
+        return this._internalState.bindings;
     }
     /**
      * Current conversation limits.
      */
     get limits() {
-        return this.configuration.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;
-            }));
+        return this._internalState.state;
     }
     /**
-     * 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
+     * Source of the conversation update.
      * @internal
      */
-    async _subscribeStreams() {
-        var _a, _b, _c;
-        try {
-            await this._subscribe();
-            log.trace("_subscribeStreams, this.entity.data=", (_a = this.entity) === null || _a === void 0 ? void 0 : _a.data);
-            const messagesObjectName = ((_b = this.entity) === null || _b === void 0 ? void 0 : _b.data)
-                .messages;
-            const rosterObjectName = ((_c = this.entity) === null || _c === void 0 ? void 0 : _c.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;
-        }
+    get _statusSource() {
+        return this._dataSource;
     }
     /**
-     * Stop listening for and firing events on this conversation.
-     * @internal
+     * Preprocess the update object.
+     * @param update The update object received from Sync.
+     * @param conversationSid The SID of the conversation in question.
      */
-    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") {
@@ -421,27 +319,23 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
             }
         }
         catch (e) {
-            log.warn("Retrieved malformed attributes from the server for conversation: " +
+            Conversation._logger.warn("Retrieved malformed attributes from the server for conversation: " +
                 conversationSid);
             update.attributes = {};
         }
         try {
-            if (update.dateCreated) {
-                update.dateCreated = new Date(update.dateCreated);
-            }
+            update.dateCreated && (update.dateCreated = new Date(update.dateCreated));
         }
         catch (e) {
-            log.warn("Retrieved malformed dateCreated from the server for conversation: " +
+            Conversation._logger.warn("Retrieved malformed dateCreated from the server for conversation: " +
                 conversationSid);
             delete update.dateCreated;
         }
         try {
-            if (update.dateUpdated) {
-                update.dateUpdated = new Date(update.dateUpdated);
-            }
+            update.dateUpdated && (update.dateUpdated = new Date(update.dateUpdated));
         }
         catch (e) {
-            log.warn("Retrieved malformed dateUpdated from the server for conversation: " +
+            Conversation._logger.warn("Retrieved malformed dateUpdated from the server for conversation: " +
                 conversationSid);
             delete update.dateUpdated;
         }
@@ -451,158 +345,44 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
             }
         }
         catch (e) {
-            log.warn("Retrieved malformed lastMessage.timestamp from the server for conversation: " +
+            Conversation._logger.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;
-                case fieldMappings.bindings:
-                    if (isEqual__default['default'](this.channelState.bindings, update.bindings)) {
-                        break;
-                    }
-                    this.channelState.bindings = update.bindings;
-                    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 (const 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.
+     * @returns The added participant.
      */
     async add(identity, attributes) {
-        return this.participantsEntity.add(identity, attributes !== null && attributes !== void 0 ? attributes : {});
+        return this._participantsEntity.add(identity, attributes !== null && attributes !== void 0 ? 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.
-     * @param bindingOptions Options for adding email participants - name and CC/To level.
+     * @param bindingOptions Options for adding email participants - name and
+     * CC/To level.
+     * @returns The added participant.
      */
     async addNonChatParticipant(proxyAddress, address, attributes = {}, bindingOptions = {}) {
-        return this.participantsEntity.addNonChatParticipant(proxyAddress, address, attributes !== null && attributes !== void 0 ? attributes : {}, bindingOptions !== null && bindingOptions !== void 0 ? bindingOptions : {});
+        return this._participantsEntity.addNonChatParticipant(proxyAddress, address, attributes !== null && attributes !== void 0 ? attributes : {}, bindingOptions !== null && bindingOptions !== void 0 ? bindingOptions : {});
     }
     /**
-     * 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.
+     * 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) {
+        var _a;
         await this._subscribeStreams();
-        if (index < (this.lastReadMessageIndex || 0)) {
+        if (index < ((_a = this.lastReadMessageIndex) !== null && _a !== void 0 ? _a : 0)) {
             return await this._setLastReadMessageIndex(this.lastReadMessageIndex);
         }
         return await this._setLastReadMessageIndex(index);
@@ -611,7 +391,7 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * Delete the conversation and unsubscribe from its events.
      */
     async delete() {
-        await this.services.commandExecutor.mutateResource("delete", this.links.self);
+        await this._services.commandExecutor.mutateResource("delete", this._links.self);
         return this;
     }
     /**
@@ -623,39 +403,43 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
     }
     /**
      * 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.
+     * @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);
+        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();
+        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 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.
+     * 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() {
         var _a;
-        const url = new index.UriBuilder(this.configuration.links.conversations)
+        const url = new index.UriBuilder(this._configuration.links.conversations)
             .path(this.sid)
             .build();
-        const response = await this.services.network.get(url);
+        const response = await this._services.network.get(url);
         return (_a = response.body.participants_count) !== null && _a !== void 0 ? _a : 0;
     }
     /**
@@ -663,53 +447,55 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * @param participantSid Participant SID.
      */
     async getParticipantBySid(participantSid) {
-        return this.participantsEntity.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 !== null && identity !== void 0 ? identity : "");
+        return this._participantsEntity.getParticipantByIdentity(identity !== null && identity !== void 0 ? 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 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.
+     * 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() {
         var _a;
-        const url = new index.UriBuilder(this.configuration.links.conversations)
+        const url = new index.UriBuilder(this._configuration.links.conversations)
             .path(this.sid)
             .build();
-        const response = await this.services.network.get(url);
+        const response = await this._services.network.get(url);
         return (_a = response.body.messages_count) !== null && _a !== void 0 ? _a : 0;
     }
     /**
-     * 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.
+     * 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 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.
+     * 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)
+        const url = new index.UriBuilder(this._configuration.links.myConversations)
             .path(this.sid)
             .build();
-        const response = await this.services.network.get(url);
+        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");
         }
@@ -723,8 +509,8 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * Join the conversation and subscribe to its events.
      */
     async join() {
-        await this.services.commandExecutor.mutateResource("post", this.links.participants, {
-            identity: this.configuration.userIdentity,
+        await this._services.commandExecutor.mutateResource("post", this._links.participants, {
+            identity: this._configuration.userIdentity,
         });
         return this;
     }
@@ -732,8 +518,8 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * Leave the conversation.
      */
     async leave() {
-        if (this.channelState.status === "joined") {
-            await this.services.commandExecutor.mutateResource("delete", `${this.links.participants}/${this.configuration.userIdentity}`);
+        if (this._internalState.status === "joined") {
+            await this._services.commandExecutor.mutateResource("delete", `${this._links.participants}/${this._configuration.userIdentity}`);
         }
         return this;
     }
@@ -742,15 +528,14 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * argument, it will assume that the string is an identity or SID.
      * @param participant Identity, SID or the participant object to remove.
      */
-    /* eslint-disable @typescript-eslint/ban-ts-comment */
-    // @ts-ignore TODO: fix validateTypesAsync typing
     async removeParticipant(participant) {
-        await this.participantsEntity.remove(typeof participant === "string" ? participant : participant.sid);
+        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.
+     * `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.
@@ -758,22 +543,23 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
     async sendMessage(message, messageAttributes, emailOptions) {
         var _a, _b;
         if (typeof message === "string" || message === null) {
-            const response = await this.messagesEntity.send(message, messageAttributes, emailOptions);
+            const response = await this._messagesEntity.send(message, messageAttributes, emailOptions);
             return (_a = index.parseToNumber(response.index)) !== null && _a !== void 0 ? _a : 0;
         }
-        const response = await this.messagesEntity.sendMedia(message, messageAttributes, emailOptions);
+        const response = await this._messagesEntity.sendMedia(message, messageAttributes, emailOptions);
         return (_b = index.parseToNumber(response.index)) !== null && _b !== void 0 ? _b : 0;
     }
     /**
      * New interface to prepare for sending a message.
-     * Use instead of `sendMessage`.
+     * Use this instead of {@link Message.sendMessage}.
      * @return A MessageBuilder to help set all message sending options.
      */
     prepareMessage() {
-        return new messageBuilder.MessageBuilder(this.limits, this.messagesEntity);
+        return new messageBuilder.MessageBuilder(this.limits, this._messagesEntity);
     }
     /**
-     * Set last read message index of the conversation to the index of the last known message.
+     * 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() {
@@ -782,7 +568,7 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
         if (messagesPage.items.length > 0) {
             return this.advanceLastReadMessageIndex(messagesPage.items[0].index);
         }
-        return Promise.resolve(0);
+        return 0;
     }
     /**
      * Set all messages in the conversation unread.
@@ -797,23 +583,25 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * @param notificationLevel New user notification level.
      */
     async setUserNotificationLevel(notificationLevel) {
-        await this.services.commandExecutor.mutateResource("post", `${this.configuration.links.myConversations}/${this.sid}`, {
+        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.
+     * 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);
+        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, {
+        await this._services.commandExecutor.mutateResource("post", this._links.self, {
             attributes: attributes !== undefined ? JSON.stringify(attributes) : undefined,
         });
         return this;
@@ -823,15 +611,15 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
      * @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 });
+        if (this._internalState.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}.
+     * @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) {
@@ -840,25 +628,251 @@ class Conversation extends replayEventEmitter.ReplayEventEmitter {
     }
     /**
      * Update the unique name of the conversation.
-     * @param uniqueName New unique name for the conversation. Setting unique name to null removes it.
+     * @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, {
+        if (this._internalState.uniqueName !== uniqueName) {
+            uniqueName || (uniqueName = "");
+            await this._services.commandExecutor.mutateResource("post", this._links.self, {
                 unique_name: uniqueName,
             });
         }
         return this;
     }
+    /**
+     * 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
+     */
+    async _subscribe() {
+        if (this._entityPromise) {
+            return this._entityPromise;
+        }
+        this._entityPromise = this._services.syncClient.document({
+            id: this._entityName,
+            mode: "open_existing",
+        });
+        try {
+            this._entity = await this._entityPromise;
+            this._entity.on("updated", (args) => this._update(args.data));
+            this._entity.on("removed", () => this.emit("removed", this));
+            this._update(this._entity.data);
+            return this._entity;
+        }
+        catch (err) {
+            this._entity = null;
+            this._entityPromise = null;
+            if (this._services.syncClient.connectionState != "disconnected") {
+                Conversation._logger.error("Failed to get conversation object", err);
+            }
+            Conversation._logger.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() {
+        var _a, _b;
+        try {
+            await this._subscribe();
+            Conversation._logger.trace("_subscribeStreams, this.entity.data=", (_a = this._entity) === null || _a === void 0 ? void 0 : _a.data);
+            const data = (_b = this._entity) === null || _b === void 0 ? void 0 : _b.data;
+            const messagesObjectName = data.messages;
+            const rosterObjectName = data.roster;
+            await Promise.all([
+                this._messagesEntity.subscribe(messagesObjectName),
+                this._participantsEntity.subscribe(rosterObjectName),
+            ]);
+        }
+        catch (err) {
+            if (this._services.syncClient.connectionState !== "disconnected") {
+                Conversation._logger.error("Failed to subscribe on conversation objects", this.sid, err);
+            }
+            Conversation._logger.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._dataSource = source;
+        if (this._internalState.status === status) {
+            return;
+        }
+        this._internalState.status = status;
+        if (status === "joined") {
+            this._subscribeStreams().catch((err) => {
+                Conversation._logger.debug("ERROR while setting conversation status " + status, err);
+                if (this._services.syncClient.connectionState !== "disconnected") {
+                    throw err;
+                }
+            });
+            return;
+        }
+        if (this._entityPromise) {
+            this._unsubscribe().catch((err) => {
+                Conversation._logger.debug("ERROR while setting conversation status " + status, err);
+                if (this._services.syncClient.connectionState !== "disconnected") {
+                    throw err;
+                }
+            });
+        }
+    }
+    /**
+     * Update the local conversation object with new values.
+     * @internal
+     */
+    _update(update) {
+        var _a, _b, _c, _d, _e;
+        Conversation._logger.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._internalState.status === update.status) {
+                        break;
+                    }
+                    this._internalState.status = update.status;
+                    updateReasons.add(localKey);
+                    break;
+                case fieldMappings.attributes:
+                    if (isEqual__default["default"](this._internalState.attributes, update.attributes)) {
+                        break;
+                    }
+                    this._internalState.attributes = update.attributes;
+                    updateReasons.add(localKey);
+                    break;
+                case fieldMappings.lastConsumedMessageIndex:
+                    if (update.lastConsumedMessageIndex === undefined ||
+                        update.lastConsumedMessageIndex ===
+                            this._internalState.lastReadMessageIndex) {
+                        break;
+                    }
+                    this._internalState.lastReadMessageIndex =
+                        update.lastConsumedMessageIndex;
+                    updateReasons.add("lastReadMessageIndex");
+                    break;
+                case fieldMappings.lastMessage:
+                    if (this._internalState.lastMessage && !update.lastMessage) {
+                        delete this._internalState.lastMessage;
+                        updateReasons.add(localKey);
+                        break;
+                    }
+                    this._internalState.lastMessage =
+                        this._internalState.lastMessage || {};
+                    if (((_a = update.lastMessage) === null || _a === void 0 ? void 0 : _a.index) !== undefined &&
+                        update.lastMessage.index !== this._internalState.lastMessage.index) {
+                        this._internalState.lastMessage.index = update.lastMessage.index;
+                        updateReasons.add(localKey);
+                    }
+                    if (((_b = update.lastMessage) === null || _b === void 0 ? void 0 : _b.timestamp) !== undefined &&
+                        ((_d = (_c = this._internalState.lastMessage) === null || _c === void 0 ? void 0 : _c.dateCreated) === null || _d === void 0 ? void 0 : _d.getTime()) !==
+                            update.lastMessage.timestamp.getTime()) {
+                        this._internalState.lastMessage.dateCreated =
+                            update.lastMessage.timestamp;
+                        updateReasons.add(localKey);
+                    }
+                    if (isEqual__default["default"](this._internalState.lastMessage, {})) {
+                        delete this._internalState.lastMessage;
+                    }
+                    break;
+                case fieldMappings.state:
+                    const state = update.state || undefined;
+                    if (state !== undefined) {
+                        state.dateUpdated = new Date(state.dateUpdated);
+                    }
+                    if (isEqual__default["default"](this._internalState.state, state)) {
+                        break;
+                    }
+                    this._internalState.state = state;
+                    updateReasons.add(localKey);
+                    break;
+                case fieldMappings.bindings:
+                    if (isEqual__default["default"](this._internalState.bindings, update.bindings)) {
+                        break;
+                    }
+                    this._internalState.bindings = update.bindings;
+                    updateReasons.add(localKey);
+                    break;
+                default:
+                    const isDate = update[key] instanceof Date;
+                    const keysMatchAsDates = isDate &&
+                        ((_e = this._internalState[localKey]) === null || _e === void 0 ? void 0 : _e.getTime()) === update[key].getTime();
+                    const keysMatchAsNonDates = !isDate && this[localKey] === update[key];
+                    if (keysMatchAsDates || keysMatchAsNonDates) {
+                        break;
+                    }
+                    this._internalState[localKey] = update[key];
+                    updateReasons.add(localKey);
+            }
+        }
+        if (updateReasons.size > 0) {
+            this.emit("updated", {
+                conversation: this,
+                updateReasons: [...updateReasons],
+            });
+        }
+    }
+    /**
+     * Handle onMessageAdded event.
+     */
+    _onMessageAdded(message) {
+        for (const participant of this._participants.values()) {
+            if (participant.identity === message.author) {
+                participant._endTyping();
+                break;
+            }
+        }
+        this.emit("messageAdded", message);
+    }
+    /**
+     * Set last read message index.
+     * @param index New index to set.
+     */
+    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;
+    }
 }
 /**
  * Fired when a participant has joined the conversation.
  *
  * Parameters:
- * 1. {@link Participant} `participant` - participant that joined the conversation
+ * 1. {@link Participant} `participant` - participant that joined the
+ * conversation
  * @event
  */
 Conversation.participantJoined = "participantJoined";
@@ -866,7 +880,8 @@ Conversation.participantJoined = "participantJoined";
  * Fired when a participant has left the conversation.
  *
  * Parameters:
- * 1. {@link Participant} `participant` - participant that left the conversation
+ * 1. {@link Participant} `participant` - participant that left the
+ * conversation
  * @event
  */
 Conversation.participantLeft = "participantLeft";
@@ -874,9 +889,12 @@ 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
+ * 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 the update
  * @event
  */
 Conversation.participantUpdated = "participantUpdated";
@@ -900,9 +918,11 @@ 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:
+ * 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
+ *     * {@link MessageUpdateReason}[] `updateReasons` - array of reasons for
+ *     the update
  * @event
  */
 Conversation.messageUpdated = "messageUpdated";
@@ -910,7 +930,8 @@ Conversation.messageUpdated = "messageUpdated";
  * Fired when a participant has stopped typing.
  *
  * Parameters:
- * 1. {@link Participant} `participant` - the participant that has stopped typing
+ * 1. {@link Participant} `participant` - the participant that has stopped
+ * typing
  * @event
  */
 Conversation.typingEnded = "typingEnded";
@@ -918,7 +939,8 @@ Conversation.typingEnded = "typingEnded";
  * Fired when a participant has started typing.
  *
  * Parameters:
- * 1. {@link Participant} `participant` - the participant that has started typing
+ * 1. {@link Participant} `participant` - the participant that has started
+ * typing
  * @event
  */
 Conversation.typingStarted = "typingStarted";
@@ -926,20 +948,28 @@ 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
+ * 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 the update
  * @event
  */
 Conversation.updated = "updated";
 /**
- * Fired when the conversation was destroyed or the currently-logged-in user has left private conversation.
+ * 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";
+/**
+ * Logger instance.
+ */
+Conversation._logger = logger.Logger.scope("Conversation");
 tslib_es6.__decorate([
     declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString, attributes.optionalAttributesValidator),
     tslib_es6.__metadata("design:type", Function),
@@ -985,9 +1015,8 @@ tslib_es6.__decorate([
 tslib_es6.__decorate([
     declarativeTypeValidator.validateTypesAsync([
         "string",
+        FormData,
         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) => {
@@ -1027,7 +1056,7 @@ tslib_es6.__decorate([
     tslib_es6.__metadata("design:returntype", Promise)
 ], Conversation.prototype, "updateAttributes", null);
 tslib_es6.__decorate([
-    declarativeTypeValidator.validateTypesAsync(["string"]),
+    declarativeTypeValidator.validateTypesAsync("string"),
     tslib_es6.__metadata("design:type", Function),
     tslib_es6.__metadata("design:paramtypes", [String]),
     tslib_es6.__metadata("design:returntype", Promise)