@twilio/conversations 2.0.0-rc.1 → 2.0.0-rc.3

package/dist/react-native.js

@@ -132,13 +132,14 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var loglevelLog = require('loglevel');
 var iso8601Duration = require('iso8601-duration');
+var JsonDiff = require('rfc6902');
+var declarativeTypeValidator = require('@twilio/declarative-type-validator');
+var replayEventEmitter = require('@twilio/replay-event-emitter');
 var operationRetrier = require('@twilio/operation-retrier');
 var twilsock = require('twilsock');
 var notifications = require('@twilio/notifications');
 var twilioSync = require('twilio-sync');
 var mcsClient = require('@twilio/mcs-client');
-var JsonDiff = require('rfc6902');
-var declarativeTypeValidator = require('@twilio/declarative-type-validator');
 var uuid = require('uuid');
 
 function _interopNamespace(e) {
@@ -190,478 +191,6 @@ function __metadata(metadataKey, metadataValue) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
 }
 
-var domain;
-
-// This constructor is used to store event handlers. Instantiating this is
-// faster than explicitly calling `Object.create(null)` to get a "clean" empty
-// object (tested with v8 v4.9).
-function EventHandlers() {}
-EventHandlers.prototype = Object.create(null);
-
-function EventEmitter() {
-  EventEmitter.init.call(this);
-}
-
-// nodejs oddity
-// require('events') === require('events').EventEmitter
-EventEmitter.EventEmitter = EventEmitter;
-
-EventEmitter.usingDomains = false;
-
-EventEmitter.prototype.domain = undefined;
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._maxListeners = undefined;
-
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-EventEmitter.defaultMaxListeners = 10;
-
-EventEmitter.init = function() {
-  this.domain = null;
-  if (EventEmitter.usingDomains) {
-    // if there is an active domain, then attach to it.
-    if (domain.active ) ;
-  }
-
-  if (!this._events || this._events === Object.getPrototypeOf(this)._events) {
-    this._events = new EventHandlers();
-    this._eventsCount = 0;
-  }
-
-  this._maxListeners = this._maxListeners || undefined;
-};
-
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || isNaN(n))
-    throw new TypeError('"n" argument must be a positive number');
-  this._maxListeners = n;
-  return this;
-};
-
-function $getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
-}
-
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return $getMaxListeners(this);
-};
-
-// These standalone emit* functions are used to optimize calling of event
-// handlers for fast cases because emit() itself often has a variable number of
-// arguments and can be deoptimized because of that. These functions always have
-// the same number of arguments and thus do not get deoptimized, so the code
-// inside them can execute faster.
-function emitNone(handler, isFn, self) {
-  if (isFn)
-    handler.call(self);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self);
-  }
-}
-function emitOne(handler, isFn, self, arg1) {
-  if (isFn)
-    handler.call(self, arg1);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1);
-  }
-}
-function emitTwo(handler, isFn, self, arg1, arg2) {
-  if (isFn)
-    handler.call(self, arg1, arg2);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2);
-  }
-}
-function emitThree(handler, isFn, self, arg1, arg2, arg3) {
-  if (isFn)
-    handler.call(self, arg1, arg2, arg3);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].call(self, arg1, arg2, arg3);
-  }
-}
-
-function emitMany(handler, isFn, self, args) {
-  if (isFn)
-    handler.apply(self, args);
-  else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      listeners[i].apply(self, args);
-  }
-}
-
-EventEmitter.prototype.emit = function emit(type) {
-  var er, handler, len, args, i, events, domain;
-  var doError = (type === 'error');
-
-  events = this._events;
-  if (events)
-    doError = (doError && events.error == null);
-  else if (!doError)
-    return false;
-
-  domain = this.domain;
-
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    er = arguments[1];
-    if (domain) {
-      if (!er)
-        er = new Error('Uncaught, unspecified "error" event');
-      er.domainEmitter = this;
-      er.domain = domain;
-      er.domainThrown = false;
-      domain.emit('error', er);
-    } else if (er instanceof Error) {
-      throw er; // Unhandled 'error' event
-    } else {
-      // At least give some kind of context to the user
-      var err = new Error('Uncaught, unspecified "error" event. (' + er + ')');
-      err.context = er;
-      throw err;
-    }
-    return false;
-  }
-
-  handler = events[type];
-
-  if (!handler)
-    return false;
-
-  var isFn = typeof handler === 'function';
-  len = arguments.length;
-  switch (len) {
-    // fast cases
-    case 1:
-      emitNone(handler, isFn, this);
-      break;
-    case 2:
-      emitOne(handler, isFn, this, arguments[1]);
-      break;
-    case 3:
-      emitTwo(handler, isFn, this, arguments[1], arguments[2]);
-      break;
-    case 4:
-      emitThree(handler, isFn, this, arguments[1], arguments[2], arguments[3]);
-      break;
-    // slower
-    default:
-      args = new Array(len - 1);
-      for (i = 1; i < len; i++)
-        args[i - 1] = arguments[i];
-      emitMany(handler, isFn, this, args);
-  }
-
-  return true;
-};
-
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
-
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-
-  events = target._events;
-  if (!events) {
-    events = target._events = new EventHandlers();
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener) {
-      target.emit('newListener', type,
-                  listener.listener ? listener.listener : listener);
-
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
-    }
-    existing = events[type];
-  }
-
-  if (!existing) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] = prepend ? [listener, existing] :
-                                          [existing, listener];
-    } else {
-      // If we've already got an array, just append.
-      if (prepend) {
-        existing.unshift(listener);
-      } else {
-        existing.push(listener);
-      }
-    }
-
-    // Check for listener leak
-    if (!existing.warned) {
-      m = $getMaxListeners(target);
-      if (m && m > 0 && existing.length > m) {
-        existing.warned = true;
-        var w = new Error('Possible EventEmitter memory leak detected. ' +
-                            existing.length + ' ' + type + ' listeners added. ' +
-                            'Use emitter.setMaxListeners() to increase limit');
-        w.name = 'MaxListenersExceededWarning';
-        w.emitter = target;
-        w.type = type;
-        w.count = existing.length;
-        emitWarning(w);
-      }
-    }
-  }
-
-  return target;
-}
-function emitWarning(e) {
-  typeof console.warn === 'function' ? console.warn(e) : console.log(e);
-}
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
-
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
-
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
-
-function _onceWrap(target, type, listener) {
-  var fired = false;
-  function g() {
-    target.removeListener(type, g);
-    if (!fired) {
-      fired = true;
-      listener.apply(target, arguments);
-    }
-  }
-  g.listener = listener;
-  return g;
-}
-
-EventEmitter.prototype.once = function once(type, listener) {
-  if (typeof listener !== 'function')
-    throw new TypeError('"listener" argument must be a function');
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
-
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
-    };
-
-// emits a 'removeListener' event iff the listener was removed
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
-
-      if (typeof listener !== 'function')
-        throw new TypeError('"listener" argument must be a function');
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      list = events[type];
-      if (!list)
-        return this;
-
-      if (list === listener || (list.listener && list.listener === listener)) {
-        if (--this._eventsCount === 0)
-          this._events = new EventHandlers();
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
-
-        for (i = list.length; i-- > 0;) {
-          if (list[i] === listener ||
-              (list[i].listener && list[i].listener === listener)) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
-
-        if (position < 0)
-          return this;
-
-        if (list.length === 1) {
-          list[0] = undefined;
-          if (--this._eventsCount === 0) {
-            this._events = new EventHandlers();
-            return this;
-          } else {
-            delete events[type];
-          }
-        } else {
-          spliceOne(list, position);
-        }
-
-        if (events.removeListener)
-          this.emit('removeListener', type, originalListener || listener);
-      }
-
-      return this;
-    };
-    
-// Alias for removeListener added in NodeJS 10.0
-// https://nodejs.org/api/events.html#events_emitter_off_eventname_listener
-EventEmitter.prototype.off = function(type, listener){
-    return this.removeListener(type, listener);
-};
-
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events;
-
-      events = this._events;
-      if (!events)
-        return this;
-
-      // not listening for removeListener, no need to emit
-      if (!events.removeListener) {
-        if (arguments.length === 0) {
-          this._events = new EventHandlers();
-          this._eventsCount = 0;
-        } else if (events[type]) {
-          if (--this._eventsCount === 0)
-            this._events = new EventHandlers();
-          else
-            delete events[type];
-        }
-        return this;
-      }
-
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = Object.keys(events);
-        for (var i = 0, key; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
-        }
-        this.removeAllListeners('removeListener');
-        this._events = new EventHandlers();
-        this._eventsCount = 0;
-        return this;
-      }
-
-      listeners = events[type];
-
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners) {
-        // LIFO order
-        do {
-          this.removeListener(type, listeners[listeners.length - 1]);
-        } while (listeners[0]);
-      }
-
-      return this;
-    };
-
-EventEmitter.prototype.listeners = function listeners(type) {
-  var evlistener;
-  var ret;
-  var events = this._events;
-
-  if (!events)
-    ret = [];
-  else {
-    evlistener = events[type];
-    if (!evlistener)
-      ret = [];
-    else if (typeof evlistener === 'function')
-      ret = [evlistener.listener || evlistener];
-    else
-      ret = unwrapListeners(evlistener);
-  }
-
-  return ret;
-};
-
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
-};
-
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
-
-  if (events) {
-    var evlistener = events[type];
-
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener) {
-      return evlistener.length;
-    }
-  }
-
-  return 0;
-}
-
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
-};
-
-// About 1.5x faster than the two-arg version of Array#splice().
-function spliceOne(list, index) {
-  for (var i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1)
-    list[i] = list[k];
-  list.pop();
-}
-
-function arrayClone(arr, i) {
-  var copy = new Array(i);
-  while (i--)
-    copy[i] = arr[i];
-  return copy;
-}
-
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
-  }
-  return ret;
-}
-
 function prepareLine(prefix, args) {
     return [`${new Date().toISOString()} Conversations ${prefix}:`].concat(Array.from(args));
 }
@@ -754,84 +283,6 @@ class Configuration {
     }
 }
 
-class Network {
-    constructor(configuration, services) {
-        this.configuration = configuration;
-        this.services = services;
-        this.cache = new Map();
-        this.cacheLifetime = this.configuration.httpCacheInterval * 100;
-        this.cleanupCache();
-    }
-    isExpired(timestamp) {
-        return !this.cacheLifetime || (Date.now() - timestamp) > this.cacheLifetime;
-    }
-    cleanupCache() {
-        for (let [k, v] of this.cache) {
-            if (this.isExpired(v.timestamp)) {
-                this.cache.delete(k);
-            }
-        }
-        if (this.cache.size === 0) {
-            clearInterval(this.timer);
-        }
-    }
-    pokeTimer() {
-        this.timer = this.timer || setInterval(() => this.cleanupCache(), this.cacheLifetime * 2);
-    }
-    executeWithRetry(request, retryWhenThrottled = false) {
-        return new Promise((resolve, reject) => {
-            let codesToRetryOn = [502, 503, 504];
-            if (retryWhenThrottled) {
-                codesToRetryOn.push(429);
-            }
-            let retrier = new operationRetrier.Retrier(this.configuration.backoffConfiguration);
-            retrier.on('attempt', () => {
-                request()
-                    .then(result => retrier.succeeded(result))
-                    .catch(err => {
-                    if (codesToRetryOn.indexOf(err.status) > -1) {
-                        retrier.failed(err);
-                    }
-                    else if (err.message === 'Twilsock disconnected') {
-                        // Ugly hack. We must make a proper exceptions for twilsock
-                        retrier.failed(err);
-                    }
-                    else {
-                        // Fatal error
-                        retrier.removeAllListeners();
-                        retrier.cancel();
-                        reject(err);
-                    }
-                });
-            });
-            retrier.on('succeeded', result => { resolve(result); });
-            retrier.on('cancelled', err => reject(err));
-            retrier.on('failed', err => reject(err));
-            retrier.start();
-        });
-    }
-    async get(url) {
-        let cacheEntry = this.cache.get(url);
-        if (cacheEntry && !this.isExpired(cacheEntry.timestamp)) {
-            return cacheEntry.response;
-        }
-        const headers = {};
-        let response = await this.executeWithRetry(() => this.services.transport.get(url, headers, this.configuration.productId), this.configuration.retryWhenThrottled);
-        this.cache.set(url, { response, timestamp: Date.now() });
-        this.pokeTimer();
-        return response;
-    }
-}
-
-class NotificationTypes {
-}
-NotificationTypes.TYPING_INDICATOR = 'twilio.ipmsg.typing_indicator';
-NotificationTypes.NEW_MESSAGE = 'twilio.conversations.new_message';
-NotificationTypes.ADDED_TO_CONVERSATION = 'twilio.conversations.added_to_conversation';
-// static readonly INVITED_TO_CHANNEL = 'twilio.channel.invited_to_channel';
-NotificationTypes.REMOVED_FROM_CONVERSATION = 'twilio.conversations.removed_from_conversation';
-NotificationTypes.CONSUMPTION_UPDATE = 'twilio.channel.consumption_update';
-
 /**
  * Checks if objects are equal
  */
@@ -906,11 +357,336 @@ class UriBuilder {
     }
 }
 
-const log$8 = Logger.scope('Participant');
+const log$8 = Logger.scope('User');
+/**
+ * Extended user information.
+ * Note that `isOnline` and `isNotifiable` properties are eligible
+ * for use only if the reachability function is enabled.
+ * You may check if it is enabled by reading the value of {@link Client.reachabilityEnabled}.
+ */
+class User extends replayEventEmitter.ReplayEventEmitter {
+    /**
+     * @internal
+     */
+    constructor(identity, entityName, configuration, services) {
+        super();
+        this.promiseToFetch = null;
+        /**
+         * Fired when the properties or the reachability status of the message has been updated.
+         *
+         * Parameters:
+         * 1. object `data` - info object provided with the event. It has the following properties:
+         *     * {@link User} `user` - the user in question
+         *     * {@link UserUpdateReason}[] `updateReasons` - array of reasons for the update
+         * @event
+         */
+        this.updated = 'updated';
+        /**
+         * Fired when the client has subscribed to the user.
+         *
+         * Parameters:
+         * 1. {@link User} `user` - the user in question
+         * @event
+         */
+        this.userSubscribed = 'userSubscribed';
+        /**
+         * Fired when the client has unsubscribed from the user.
+         *
+         * Parameters:
+         * 1. {@link User} `user` - the user in question
+         * @event
+         */
+        this.userUnsubscribed = 'userUnsubscribed';
+        this.services = services;
+        this.subscribed = 'initializing';
+        this.setMaxListeners(0);
+        this.state = {
+            identity,
+            entityName,
+            friendlyName: null,
+            attributes: {},
+            online: null,
+            notifiable: null
+        };
+        this._initializationPromise = new Promise((resolve) => {
+            this._resolveInitializationPromise = resolve;
+        });
+        if (configuration !== null) {
+            this._resolveInitialization(configuration, identity, entityName, false);
+        }
+    }
+    /**
+     * User identity.
+     */
+    get identity() { return this.state.identity; }
+    set identity(identity) { this.state.identity = identity; }
+    set entityName(name) { this.state.entityName = name; }
+    /**
+     * Custom attributes of the user.
+     */
+    get attributes() { return this.state.attributes; }
+    /**
+     * Friendly name of the user, null if not set.
+     */
+    get friendlyName() { return this.state.friendlyName; }
+    /**
+     * Status of the real-time conversation connection of the user.
+     */
+    get isOnline() { return this.state.online; }
+    /**
+     * User push notification registration status.
+     */
+    get isNotifiable() { return this.state.notifiable; }
+    /**
+     * True if this user is receiving real-time status updates.
+     */
+    get isSubscribed() { return this.subscribed == 'subscribed'; }
+    // Handles service updates
+    async _update(key, value) {
+        await this._initializationPromise;
+        let updateReasons = [];
+        log$8.debug('User for', this.state.identity, 'updated:', key, value);
+        switch (key) {
+            case 'friendlyName':
+                if (this.state.friendlyName !== value.value) {
+                    updateReasons.push('friendlyName');
+                    this.state.friendlyName = value.value;
+                }
+                break;
+            case 'attributes':
+                const updateAttributes = parseAttributes(value.value, `Retrieved malformed attributes from the server for user: ${this.state.identity}`, log$8);
+                if (!isDeepEqual(this.state.attributes, updateAttributes)) {
+                    this.state.attributes = updateAttributes;
+                    updateReasons.push('attributes');
+                }
+                break;
+            case 'reachability':
+                if (this.state.online !== value.online) {
+                    this.state.online = value.online;
+                    updateReasons.push('reachabilityOnline');
+                }
+                if (this.state.notifiable !== value.notifiable) {
+                    this.state.notifiable = value.notifiable;
+                    updateReasons.push('reachabilityNotifiable');
+                }
+                break;
+            default:
+                return;
+        }
+        if (updateReasons.length > 0) {
+            this.emit('updated', { user: this, updateReasons: updateReasons });
+        }
+    }
+    // Fetch reachability info
+    async _updateReachabilityInfo(map, update) {
+        await this._initializationPromise;
+        if (!this.configuration.reachabilityEnabled) {
+            return Promise.resolve();
+        }
+        return map.get('reachability')
+            .then(update)
+            .catch(err => { log$8.warn('Failed to get reachability info for ', this.state.identity, err); });
+    }
+    // Fetch user
+    async _fetch() {
+        await this._initializationPromise;
+        if (!this.state.entityName) {
+            return this;
+        }
+        this.promiseToFetch = this.services.syncClient.map({
+            id: this.state.entityName,
+            mode: 'open_existing',
+            includeItems: true
+        })
+            .then(map => {
+            this.entity = map;
+            map.on('itemUpdated', args => {
+                log$8.debug(this.state.entityName + ' (' + this.state.identity + ') itemUpdated: ' + args.item.key);
+                return this._update(args.item.key, args.item.data);
+            });
+            return Promise.all([
+                map.get('friendlyName')
+                    .then(item => this._update(item.key, item.data)),
+                map.get('attributes')
+                    .then(item => this._update(item.key, item.data)),
+                this._updateReachabilityInfo(map, item => this._update(item.key, item.data))
+            ]);
+        })
+            .then(() => {
+            log$8.debug('Fetched for', this.identity);
+            this.subscribed = 'subscribed';
+            this.emit('userSubscribed', this);
+            return this;
+        })
+            .catch(err => {
+            this.promiseToFetch = null;
+            throw err;
+        });
+        return this.promiseToFetch;
+    }
+    async _ensureFetched() {
+        await this._initializationPromise;
+        return this.promiseToFetch || this._fetch();
+    }
+    /**
+     * Edit user attributes.
+     * @param attributes New attributes.
+     */
+    async updateAttributes(attributes) {
+        await this._initializationPromise;
+        if (this.subscribed == 'unsubscribed') {
+            throw new Error('Can\'t modify unsubscribed object');
+        }
+        await this.services.commandExecutor.mutateResource('post', this.links.self, {
+            attributes: JSON.stringify(attributes)
+        });
+        return this;
+    }
+    /**
+     * Update the friendly name of the user.
+     * @param friendlyName New friendly name.
+     */
+    async updateFriendlyName(friendlyName) {
+        await this._initializationPromise;
+        if (this.subscribed == 'unsubscribed') {
+            throw new Error('Can\'t modify unsubscribed object');
+        }
+        await this.services.commandExecutor.mutateResource('post', this.links.self, {
+            friendly_name: friendlyName
+        });
+        return this;
+    }
+    /**
+     * Remove the user from the subscription list.
+     * @return A promise of completion.
+     */
+    async unsubscribe() {
+        await this._initializationPromise;
+        if (this.promiseToFetch) {
+            await this.promiseToFetch;
+            this.entity.close();
+            this.promiseToFetch = null;
+            this.subscribed = 'unsubscribed';
+            this.emit('userUnsubscribed', this);
+        }
+    }
+    _resolveInitialization(configuration, identity, entityName, emitUpdated) {
+        this.configuration = configuration;
+        this.identity = identity;
+        this.entityName = entityName;
+        this.links = {
+            self: `${this.configuration.links.users}/${this.identity}`
+        };
+        this._resolveInitializationPromise();
+        if (emitUpdated) {
+            this.emit('updated', {
+                user: this,
+                updateReasons: [
+                    'friendlyName',
+                    'attributes',
+                    'reachabilityOnline',
+                    'reachabilityNotifiable'
+                ]
+            });
+        }
+    }
+}
+__decorate([
+    declarativeTypeValidator.validateTypesAsync(['string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], User.prototype, "updateAttributes", null);
+__decorate([
+    declarativeTypeValidator.validateTypesAsync(['string']),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String]),
+    __metadata("design:returntype", Promise)
+], User.prototype, "updateFriendlyName", null);
+
+class Network {
+    constructor(configuration, services) {
+        this.configuration = configuration;
+        this.services = services;
+        this.cache = new Map();
+        this.cacheLifetime = this.configuration.httpCacheInterval * 100;
+        this.cleanupCache();
+    }
+    isExpired(timestamp) {
+        return !this.cacheLifetime || (Date.now() - timestamp) > this.cacheLifetime;
+    }
+    cleanupCache() {
+        for (let [k, v] of this.cache) {
+            if (this.isExpired(v.timestamp)) {
+                this.cache.delete(k);
+            }
+        }
+        if (this.cache.size === 0) {
+            clearInterval(this.timer);
+        }
+    }
+    pokeTimer() {
+        this.timer = this.timer || setInterval(() => this.cleanupCache(), this.cacheLifetime * 2);
+    }
+    executeWithRetry(request, retryWhenThrottled = false) {
+        return new Promise((resolve, reject) => {
+            let codesToRetryOn = [502, 503, 504];
+            if (retryWhenThrottled) {
+                codesToRetryOn.push(429);
+            }
+            let retrier = new operationRetrier.Retrier(this.configuration.backoffConfiguration);
+            retrier.on('attempt', () => {
+                request()
+                    .then(result => retrier.succeeded(result))
+                    .catch(err => {
+                    if (codesToRetryOn.indexOf(err.status) > -1) {
+                        retrier.failed(err);
+                    }
+                    else if (err.message === 'Twilsock disconnected') {
+                        // Ugly hack. We must make a proper exceptions for twilsock
+                        retrier.failed(err);
+                    }
+                    else {
+                        // Fatal error
+                        retrier.removeAllListeners();
+                        retrier.cancel();
+                        reject(err);
+                    }
+                });
+            });
+            retrier.on('succeeded', result => { resolve(result); });
+            retrier.on('cancelled', err => reject(err));
+            retrier.on('failed', err => reject(err));
+            retrier.start();
+        });
+    }
+    async get(url) {
+        let cacheEntry = this.cache.get(url);
+        if (cacheEntry && !this.isExpired(cacheEntry.timestamp)) {
+            return cacheEntry.response;
+        }
+        const headers = {};
+        let response = await this.executeWithRetry(() => this.services.transport.get(url, headers, this.configuration.productId), this.configuration.retryWhenThrottled);
+        this.cache.set(url, { response, timestamp: Date.now() });
+        this.pokeTimer();
+        return response;
+    }
+}
+
+class NotificationTypes {
+}
+NotificationTypes.TYPING_INDICATOR = 'twilio.ipmsg.typing_indicator';
+NotificationTypes.NEW_MESSAGE = 'twilio.conversations.new_message';
+NotificationTypes.ADDED_TO_CONVERSATION = 'twilio.conversations.added_to_conversation';
+// static readonly INVITED_TO_CHANNEL = 'twilio.channel.invited_to_channel';
+NotificationTypes.REMOVED_FROM_CONVERSATION = 'twilio.conversations.removed_from_conversation';
+NotificationTypes.CONSUMPTION_UPDATE = 'twilio.channel.consumption_update';
+
+const log$7 = Logger.scope('Participant');
 /**
  * A participant represents a remote client in a conversation.
  */
-class Participant extends EventEmitter {
+class Participant extends replayEventEmitter.ReplayEventEmitter {
     /**
      * @internal
      */
@@ -920,7 +696,7 @@ class Participant extends EventEmitter {
         this.links = links;
         this.services = services;
         this.state = {
-            attributes: parseAttributes(data.attributes, 'Retrieved malformed attributes from the server for participant: ' + sid, log$8),
+            attributes: parseAttributes(data.attributes, 'Retrieved malformed attributes from the server for participant: ' + sid, log$7),
             dateCreated: data.dateCreated ? parseTime$1(data.dateCreated) : null,
             dateUpdated: data.dateCreated ? parseTime$1(data.dateUpdated) : null,
             sid: sid,
@@ -1009,7 +785,7 @@ class Participant extends EventEmitter {
      */
     _update(data) {
         let updateReasons = [];
-        let updateAttributes = parseAttributes(data.attributes, 'Retrieved malformed attributes from the server for participant: ' + this.state.sid, log$8);
+        let updateAttributes = parseAttributes(data.attributes, 'Retrieved malformed attributes from the server for participant: ' + this.state.sid, log$7);
         if (data.attributes && !isDeepEqual(this.state.attributes, updateAttributes)) {
             this.state.attributes = updateAttributes;
             updateReasons.push('attributes');
@@ -1107,14 +883,14 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], Participant.prototype, "updateAttributes", null);
 
-const log$7 = Logger.scope('Participants');
+const log$6 = Logger.scope('Participants');
 /**
  * @classdesc Represents the collection of participants for the conversation
  * @fires Participants#participantJoined
  * @fires Participants#participantLeft
  * @fires Participants#participantUpdated
  */
-class Participants extends EventEmitter {
+class Participants extends replayEventEmitter.ReplayEventEmitter {
     constructor(conversation, participants, links, configuration, services) {
         super();
         this.conversation = conversation;
@@ -1135,14 +911,14 @@ class Participants extends EventEmitter {
             || this.services.syncClient.map({ id: rosterObjectName, mode: 'open_existing' })
                 .then(rosterMap => {
                 rosterMap.on('itemAdded', args => {
-                    log$7.debug(this.conversation.sid + ' itemAdded: ' + args.item.key);
+                    log$6.debug(this.conversation.sid + ' itemAdded: ' + args.item.key);
                     this.upsertParticipant(args.item.key, args.item.data)
                         .then(participant => {
                         this.emit('participantJoined', participant);
                     });
                 });
                 rosterMap.on('itemRemoved', args => {
-                    log$7.debug(this.conversation.sid + ' itemRemoved: ' + args.key);
+                    log$6.debug(this.conversation.sid + ' itemRemoved: ' + args.key);
                     let participantSid = args.key;
                     if (!this.participants.has(participantSid)) {
                         return;
@@ -1152,7 +928,7 @@ class Participants extends EventEmitter {
                     this.emit('participantLeft', leftParticipant);
                 });
                 rosterMap.on('itemUpdated', args => {
-                    log$7.debug(this.conversation.sid + ' itemUpdated: ' + args.item.key);
+                    log$6.debug(this.conversation.sid + ' itemUpdated: ' + args.item.key);
                     this.upsertParticipant(args.item.key, args.item.data);
                 });
                 let participantsPromises = [];
@@ -1170,9 +946,9 @@ class Participants extends EventEmitter {
                 .catch(err => {
                 this.rosterEntityPromise = null;
                 if (this.services.syncClient.connectionState != 'disconnected') {
-                    log$7.error('Failed to get roster object for conversation', this.conversation.sid, err);
+                    log$6.error('Failed to get roster object for conversation', this.conversation.sid, err);
                 }
-                log$7.debug('ERROR: Failed to get roster object for conversation', this.conversation.sid, err);
+                log$6.debug('ERROR: Failed to get roster object for conversation', this.conversation.sid, err);
                 throw err;
             });
     }
@@ -1248,9 +1024,9 @@ class Participants extends EventEmitter {
      * @param attributes
      * @returns {Promise<any>}
      */
-    addNonChatParticipant(proxyAddress, address, attributes = {}) {
+    addNonChatParticipant(proxyAddress, address, attributes) {
         return this.services.commandExecutor.mutateResource('post', this.links.participants, {
-            attributes: JSON.stringify(attributes),
+            attributes: typeof attributes !== 'undefined' ? JSON.stringify(attributes) : undefined,
             messaging_binding: {
                 address,
                 proxy_address: proxyAddress
@@ -1320,7 +1096,7 @@ class Media {
      */
     get size() { return this.state.size; }
     /**
-     * Media category, can be one of the {MediaCategory} values.
+     * Media category, can be one of the {@link MediaCategory} values.
      */
     get category() { return this.state.category; }
     /**
@@ -1513,11 +1289,11 @@ class DetailedDeliveryReceipt {
     }
 }
 
-const log$6 = Logger.scope('Message');
+const log$5 = Logger.scope('Message');
 /**
  * A message in a conversation.
  */
-class Message extends EventEmitter {
+class Message extends replayEventEmitter.ReplayEventEmitter {
     /**
      * @internal
      */
@@ -1537,7 +1313,7 @@ class Message extends EventEmitter {
             timestamp: data.timestamp ? new Date(data.timestamp) : null,
             dateUpdated: data.dateUpdated ? new Date(data.dateUpdated) : null,
             lastUpdatedBy: (_c = data.lastUpdatedBy) !== null && _c !== void 0 ? _c : null,
-            attributes: parseAttributes(data.attributes, `Got malformed attributes for the message ${data.sid}`, log$6),
+            attributes: parseAttributes(data.attributes, `Got malformed attributes for the message ${data.sid}`, log$5),
             type: (_d = data.type) !== null && _d !== void 0 ? _d : 'text',
             media: (data.type && data.type === 'media' && data.media)
                 ? new Media(data.media, this.services) : null,
@@ -1652,7 +1428,7 @@ class Message extends EventEmitter {
             this.state.timestamp = new Date(data.timestamp);
             updateReasons.push('dateCreated');
         }
-        let updatedAttributes = parseAttributes(data.attributes, `Got malformed attributes for the message ${this.sid}`, log$6);
+        let updatedAttributes = parseAttributes(data.attributes, `Got malformed attributes for the message ${this.sid}`, log$5);
         if (!isDeepEqual(this.state.attributes, updatedAttributes)) {
             this.state.attributes = updatedAttributes;
             updateReasons.push('attributes');
@@ -1684,14 +1460,14 @@ class Message extends EventEmitter {
         if (this.state.participantSid) {
             participant = await this.conversation.getParticipantBySid(this.participantSid)
                 .catch(() => {
-                log$6.debug(`Participant with sid "${this.participantSid}" not found for message ${this.sid}`);
+                log$5.debug(`Participant with sid "${this.participantSid}" not found for message ${this.sid}`);
                 return null;
             });
         }
         if (!participant && this.state.author) {
             participant = await this.conversation.getParticipantByIdentity(this.state.author)
                 .catch(() => {
-                log$6.debug(`Participant with identity "${this.author}" not found for message ${this.sid}`);
+                log$5.debug(`Participant with identity "${this.author}" not found for message ${this.sid}`);
                 return null;
             });
         }
@@ -1814,11 +1590,11 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], Message.prototype, "attachTemporaryUrlsFor", null);
 
-const log$5 = Logger.scope('Messages');
+const log$4 = Logger.scope('Messages');
 /**
  * Represents the collection of messages in a conversation
  */
-class Messages extends EventEmitter {
+class Messages extends replayEventEmitter.ReplayEventEmitter {
     constructor(conversation, configuration, services) {
         super();
         this.conversation = conversation;
@@ -1842,7 +1618,7 @@ class Messages extends EventEmitter {
         try {
             const list = await this.messagesListPromise;
             list.on('itemAdded', (args) => {
-                log$5.debug(`${this.conversation.sid} itemAdded: ${args.item.index}`);
+                log$4.debug(`${this.conversation.sid} itemAdded: ${args.item.index}`);
                 const links = {
                     self: `${this.conversation.links.messages}/${args.item.data.sid}`,
                     conversation: this.conversation.links.self,
@@ -1850,7 +1626,7 @@ class Messages extends EventEmitter {
                 };
                 const message = new Message(args.item.index, args.item.data, this.conversation, links, this.configuration, this.services);
                 if (this.messagesByIndex.has(message.index)) {
-                    log$5.debug('Message arrived, but is already known and ignored', this.conversation.sid, message.index);
+                    log$4.debug('Message arrived, but is already known and ignored', this.conversation.sid, message.index);
                     return;
                 }
                 this.messagesByIndex.set(message.index, message);
@@ -1858,7 +1634,7 @@ class Messages extends EventEmitter {
                 this.emit('messageAdded', message);
             });
             list.on('itemRemoved', (args) => {
-                log$5.debug(`#{this.conversation.sid} itemRemoved: ${args.index}`);
+                log$4.debug(`#{this.conversation.sid} itemRemoved: ${args.index}`);
                 const index = args.index;
                 if (this.messagesByIndex.has(index)) {
                     let message = this.messagesByIndex.get(index);
@@ -1868,7 +1644,7 @@ class Messages extends EventEmitter {
                 }
             });
             list.on('itemUpdated', (args) => {
-                log$5.debug(`${this.conversation.sid} itemUpdated: ${args.item.index}`);
+                log$4.debug(`${this.conversation.sid} itemUpdated: ${args.item.index}`);
                 const message = this.messagesByIndex.get(args.item.index);
                 if (message) {
                     message._update(args.item.data);
@@ -1879,9 +1655,9 @@ class Messages extends EventEmitter {
         catch (err) {
             this.messagesListPromise = null;
             if (this.services.syncClient.connectionState !== 'disconnected') {
-                log$5.error('Failed to get messages object for conversation', this.conversation.sid, err);
+                log$4.error('Failed to get messages object for conversation', this.conversation.sid, err);
             }
-            log$5.debug('ERROR: Failed to get messages object for conversation', this.conversation.sid, err);
+            log$4.debug('ERROR: Failed to get messages object for conversation', this.conversation.sid, err);
             throw err;
         }
     }
@@ -1900,10 +1676,10 @@ class Messages extends EventEmitter {
      */
     async sendV2(message) {
         var _a;
-        log$5.debug('Sending message V2', message.mediaContent, message.attributes, message.emailOptions);
+        log$4.debug('Sending message V2', message.mediaContent, message.attributes, message.emailOptions);
         const media = [];
         for (const [category, mediaContent] of message.mediaContent) {
-            log$5.debug(`Adding media to a message as ${mediaContent instanceof FormData ? 'FormData' : 'SendMediaOptions'}`, mediaContent);
+            log$4.debug(`Adding media to a message as ${mediaContent instanceof FormData ? 'FormData' : 'SendMediaOptions'}`, mediaContent);
             media.push(mediaContent instanceof FormData
                 ? await this.services.mcsClient.postFormData(mediaContent, category)
                 : await this.services.mcsClient.post(mediaContent.contentType, mediaContent.media, category, mediaContent.filename));
@@ -1925,7 +1701,7 @@ class Messages extends EventEmitter {
      * @returns Returns promise which can fail
      */
     async send(message, attributes = {}, emailOptions) {
-        log$5.debug('Sending text message', message, attributes, emailOptions);
+        log$4.debug('Sending text message', message, attributes, emailOptions);
         return await this.services.commandExecutor.mutateResource('post', this.conversation.links.messages, {
             body: message !== null && message !== void 0 ? message : '',
             attributes: typeof attributes !== 'undefined'
@@ -1942,8 +1718,8 @@ class Messages extends EventEmitter {
      * @returns Returns promise which can fail
      */
     async sendMedia(mediaContent, attributes = {}, emailOptions) {
-        log$5.debug('Sending media message', mediaContent, attributes, emailOptions);
-        log$5.debug(`Sending media message as ${mediaContent instanceof FormData ? 'FormData' : 'SendMediaOptions'}`, mediaContent, attributes);
+        log$4.debug('Sending media message', mediaContent, attributes, emailOptions);
+        log$4.debug(`Sending media message as ${mediaContent instanceof FormData ? 'FormData' : 'SendMediaOptions'}`, mediaContent, attributes);
         const media = mediaContent instanceof FormData
             ? await this.services.mcsClient.postFormData(mediaContent)
             : await this.services.mcsClient.post(mediaContent.contentType, mediaContent.media, 'media', mediaContent.filename);
@@ -2017,7 +1793,13 @@ class Messages extends EventEmitter {
     }
 }
 
+/**
+ * An unsent message. Returned from {@link MessageBuilder.build}.
+ */
 class UnsentMessage {
+    /**
+     * @internal
+     */
     constructor(messagesEntity) {
         this.messagesEntity = messagesEntity;
         this.attributes = {};
@@ -2026,35 +1808,72 @@ class UnsentMessage {
     }
     /**
      * Send the prepared message to the conversation.
-     * @returns {Promise<number>} new Message's index in the Conversation's messages list
+     * @returns Index of the new message in the conversation.
      */
     async send() {
         const response = await this.messagesEntity.sendV2(this);
-        return parseToNumber(response.messageId);
+        return parseToNumber(response.index);
     }
 }
 
+/**
+ * Message builder. Allows the message to be built and sent via method chaining.
+ *
+ * Example:
+ *
+ * ```ts
+ * await testConversation.prepareMessage()
+ *   .setBody('Hello!')
+ *   .setAttributes({foo: 'bar'})
+ *   .addMedia(media1)
+ *   .addMedia(media2)
+ *   .build()
+ *   .send();
+ * ```
+ */
 class MessageBuilder {
+    /**
+     * @internal
+     */
     constructor(limits, messagesEntity) {
         this.limits = limits;
         this.message = new UnsentMessage(messagesEntity);
     }
+    /**
+     * Sets the message body.
+     * @param text Contents of the body.
+     */
     setBody(text) {
         this.message.text = text;
         return this;
     }
+    /**
+     * Sets the message subject.
+     * @param subject Contents of the subject.
+     */
     setSubject(subject) {
         this.message.emailOptions.subject = subject;
         return this;
     }
+    /**
+     * Sets the message attributes.
+     * @param attributes Message attributes.
+     */
     setAttributes(attributes) {
         this.message.attributes = attributes;
         return this;
     }
+    /**
+     * Adds media to the message.
+     * @param payload Media to add.
+     */
     addMedia(payload) {
         this.message.mediaContent.push(['media', payload]);
         return this;
     }
+    /**
+     * Builds the message, making it ready to be sent.
+     */
     build() {
         if (this.message.mediaContent.length > this.limits.mediaAttachmentsCountLimit) {
             throw new Error(`Too many media attachments in the message (${this.message.mediaContent.length} > ${this.limits.mediaAttachmentsCountLimit})`);
@@ -2070,7 +1889,7 @@ class MessageBuilder {
     }
 }
 
-const log$4 = Logger.scope('Conversation');
+const log$3 = Logger.scope('Conversation');
 const fieldMappings = {
     lastMessage: 'lastMessage',
     attributes: 'attributes',
@@ -2096,7 +1915,7 @@ function parseTime(timeString) {
 /**
  * A conversation represents communication between multiple Conversations clients
  */
-class Conversation extends EventEmitter {
+class Conversation extends replayEventEmitter.ReplayEventEmitter {
     /**
      * @internal
      */
@@ -2210,9 +2029,9 @@ class Conversation extends EventEmitter {
             this.entity = null;
             this.entityPromise = null;
             if (this.services.syncClient.connectionState != 'disconnected') {
-                log$4.error('Failed to get conversation object', err);
+                log$3.error('Failed to get conversation object', err);
             }
-            log$4.debug('ERROR: Failed to get conversation object', err);
+            log$3.debug('ERROR: Failed to get conversation object', err);
             throw err;
         });
     }
@@ -2225,7 +2044,7 @@ class Conversation extends EventEmitter {
     async _subscribeStreams() {
         try {
             await this._subscribe();
-            log$4.trace('_subscribeStreams, this.entity.data=', this.entity.data);
+            log$3.trace('_subscribeStreams, this.entity.data=', this.entity.data);
             const messagesObjectName = this.entity.data.messages;
             const rosterObjectName = this.entity.data.roster;
             await Promise.all([
@@ -2235,9 +2054,9 @@ class Conversation extends EventEmitter {
         }
         catch (err) {
             if (this.services.syncClient.connectionState !== 'disconnected') {
-                log$4.error('Failed to subscribe on conversation objects', this.sid, err);
+                log$3.error('Failed to subscribe on conversation objects', this.sid, err);
             }
-            log$4.debug('ERROR: Failed to subscribe on conversation objects', this.sid, err);
+            log$3.debug('ERROR: Failed to subscribe on conversation objects', this.sid, err);
             throw err;
         }
     }
@@ -2269,7 +2088,7 @@ class Conversation extends EventEmitter {
         if (status === 'joined') {
             this._subscribeStreams()
                 .catch(err => {
-                log$4.debug('ERROR while setting conversation status ' + status, err);
+                log$3.debug('ERROR while setting conversation status ' + status, err);
                 if (this.services.syncClient.connectionState !== 'disconnected') {
                     throw err;
                 }
@@ -2277,7 +2096,7 @@ class Conversation extends EventEmitter {
         }
         else if (this.entityPromise) {
             this._unsubscribe().catch(err => {
-                log$4.debug('ERROR while setting conversation status ' + status, err);
+                log$3.debug('ERROR while setting conversation status ' + status, err);
                 if (this.services.syncClient.connectionState !== 'disconnected') {
                     throw err;
                 }
@@ -2301,7 +2120,7 @@ class Conversation extends EventEmitter {
             }
         }
         catch (e) {
-            log$4.warn('Retrieved malformed attributes from the server for conversation: ' + conversationSid);
+            log$3.warn('Retrieved malformed attributes from the server for conversation: ' + conversationSid);
             update.attributes = {};
         }
         try {
@@ -2310,7 +2129,7 @@ class Conversation extends EventEmitter {
             }
         }
         catch (e) {
-            log$4.warn('Retrieved malformed dateCreated from the server for conversation: ' + conversationSid);
+            log$3.warn('Retrieved malformed dateCreated from the server for conversation: ' + conversationSid);
             delete update.dateCreated;
         }
         try {
@@ -2319,7 +2138,7 @@ class Conversation extends EventEmitter {
             }
         }
         catch (e) {
-            log$4.warn('Retrieved malformed dateUpdated from the server for conversation: ' + conversationSid);
+            log$3.warn('Retrieved malformed dateUpdated from the server for conversation: ' + conversationSid);
             delete update.dateUpdated;
         }
         try {
@@ -2328,7 +2147,7 @@ class Conversation extends EventEmitter {
             }
         }
         catch (e) {
-            log$4.warn('Retrieved malformed lastMessage.timestamp from the server for conversation: ' + conversationSid);
+            log$3.warn('Retrieved malformed lastMessage.timestamp from the server for conversation: ' + conversationSid);
             delete update.lastMessage.timestamp;
         }
     }
@@ -2338,7 +2157,7 @@ class Conversation extends EventEmitter {
      */
     _update(update) {
         var _a, _b, _c, _d, _e;
-        log$4.trace('_update', update);
+        log$3.trace('_update', update);
         Conversation.preprocessUpdate(update, this.sid);
         const updateReasons = new Set();
         for (const key of Object.keys(update)) {
@@ -2449,7 +2268,7 @@ class Conversation extends EventEmitter {
      * @param address User address of the participant.
      * @param attributes Attributes to be attached to the participant.
      */
-    async addNonChatParticipant(proxyAddress, address, attributes = {}) {
+    async addNonChatParticipant(proxyAddress, address, attributes) {
         return this.participantsEntity.addNonChatParticipant(proxyAddress, address, attributes !== null && attributes !== void 0 ? attributes : {});
     }
     /**
@@ -2595,8 +2414,9 @@ class Conversation extends EventEmitter {
         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.
-     * @param participant Identity or the participant object to remove.
+     * 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'
@@ -2606,7 +2426,7 @@ class Conversation extends EventEmitter {
     /**
      * Send a message to the conversation.
      * @param message Message body for the text message,
-     * `FormData` or {@link Conversation.MediaOptions) 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.
@@ -2622,7 +2442,6 @@ class Conversation extends EventEmitter {
     /**
      * New interface to prepare for sending a message.
      * Use instead of `sendMessage`.
-     * @return {MessageBuilder} [description]
      */
     prepareMessage() {
         return new MessageBuilder(this.limits, this.messagesEntity);
@@ -2802,7 +2621,7 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], Conversation.prototype, "add", null);
 __decorate([
-    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString, declarativeTypeValidator.nonEmptyString, [declarativeTypeValidator.pureObject, 'undefined']),
+    declarativeTypeValidator.validateTypesAsync(declarativeTypeValidator.nonEmptyString, declarativeTypeValidator.nonEmptyString, ['undefined', 'string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String, String, Object]),
     __metadata("design:returntype", Promise)
@@ -2876,7 +2695,7 @@ __decorate([
     __metadata("design:returntype", Promise)
 ], Conversation.prototype, "updateAttributes", null);
 __decorate([
-    declarativeTypeValidator.validateTypesAsync(['string', declarativeTypeValidator.literal(null)]),
+    declarativeTypeValidator.validateTypesAsync(['string']),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [String]),
     __metadata("design:returntype", Promise)
@@ -2914,12 +2733,12 @@ class Deferred {
     }
 }
 
-const log$3 = Logger.scope('Conversations');
+const log$2 = Logger.scope('Conversations');
 /**
  * Represents conversations collection
  * {@see Conversation}
  */
-class Conversations extends EventEmitter {
+class Conversations extends replayEventEmitter.ReplayEventEmitter {
     constructor(configuration, services) {
         super();
         this.conversations = new Map();
@@ -2971,11 +2790,11 @@ class Conversations extends EventEmitter {
         try {
             const map = await this._getMap();
             map.on('itemAdded', args => {
-                log$3.debug(`itemAdded: ${args.item.key}`);
+                log$2.debug(`itemAdded: ${args.item.key}`);
                 this._upsertConversation('sync', args.item.key, args.item.data);
             });
             map.on('itemRemoved', args => {
-                log$3.debug(`itemRemoved: ${args.key}`);
+                log$2.debug(`itemRemoved: ${args.key}`);
                 const sid = args.key;
                 if (!this.myConversationsFetched) {
                     this.tombstones.add(sid);
@@ -2993,7 +2812,7 @@ class Conversations extends EventEmitter {
                 conversation.emit('removed', conversation);
             });
             map.on('itemUpdated', args => {
-                log$3.debug(`itemUpdated: ${args.item.key}`);
+                log$2.debug(`itemUpdated: ${args.item.key}`);
                 this._upsertConversation('sync', args.item.key, args.item.data);
             });
             const myConversations = await this._fetchMyConversations();
@@ -3005,15 +2824,15 @@ class Conversations extends EventEmitter {
             await Promise.all(upserts);
             this.myConversationsFetched = true;
             this.tombstones.clear();
-            log$3.debug('The conversations list has been successfully fetched');
+            log$2.debug('The conversations list has been successfully fetched');
             return this;
         }
         catch (error) {
             const errorMessage = 'Failed to fetch the conversations list';
             if (this.services.syncClient.connectionState !== 'disconnected') {
-                log$3.error(errorMessage, error);
+                log$2.error(errorMessage, error);
             }
-            log$3.debug(`ERROR: ${errorMessage}`, error);
+            log$2.debug(`ERROR: ${errorMessage}`, error);
             throw error;
         }
     }
@@ -3057,9 +2876,6 @@ class Conversations extends EventEmitter {
             .build();
         const response = await this.services.network.get(url);
         const body = response.body;
-        if (body.type !== 'private') {
-            return null;
-        }
         const data = {
             entityName: null,
             // lastConsumedMessageIndex: body.last_read_message_index,
@@ -3096,7 +2912,7 @@ class Conversations extends EventEmitter {
         const areSourcesDifferent = conversation._statusSource() !== undefined && source !== conversation._statusSource();
         const isChannelSourceSync = source !== 'rest' || conversation._statusSource() === 'sync';
         if (areSourcesDifferent && isChannelSourceSync && source !== 'sync') {
-            log$3.trace('upsertConversation: conversation is known from sync and came from chat, ignoring', {
+            log$2.trace('upsertConversation: conversation is known from sync and came from chat, ignoring', {
                 sid: conversation.sid,
                 data: data.status,
                 conversation: conversation.status
@@ -3134,11 +2950,11 @@ class Conversations extends EventEmitter {
         conversation._update(data);
     }
     async _upsertConversation(source, sid, data) {
-        log$3.trace(`upsertConversation called for ${sid}`, data);
+        log$2.trace(`upsertConversation called for ${sid}`, data);
         const conversation = this.conversations.get(sid);
         // If the channel is known, update it
         if (conversation) {
-            log$3.trace(`upsertConversation: the conversation ${conversation.sid} is known;` +
+            log$2.trace(`upsertConversation: the conversation ${conversation.sid} is known;` +
                 `its status is known from the source ${conversation._statusSource()} ` +
                 `and the update came from the source ${source}`, conversation);
             await this._updateConversation(source, conversation, data);
@@ -3147,11 +2963,11 @@ class Conversations extends EventEmitter {
         }
         // If the conversations is deleted, ignore it
         if (['chat', 'rest'].includes(source) && this.tombstones.has(sid)) {
-            log$3.trace('upsertChannel: the channel is deleted but reappeared again from chat, ignoring', sid);
+            log$2.trace('upsertChannel: the channel is deleted but reappeared again from chat, ignoring', sid);
             return;
         }
         // If the conversation is unknown, fetch it
-        log$3.trace('upsertConversation: creating a local conversation object with sid ' + sid, data);
+        log$2.trace('upsertConversation: creating a local conversation object with sid ' + sid, data);
         const baseLink = `${this.configuration.links.conversations}/${sid}`;
         const links = {
             self: baseLink,
@@ -3214,231 +3030,16 @@ class Conversations extends EventEmitter {
     }
 }
 
-const log$2 = Logger.scope('User');
-/**
- * Extended user information.
- * Note that `isOnline` and `isNotifiable` properties are eligible
- * for use only if the reachability function is enabled.
- * You may check if it is enabled by reading the value of {@link Client.reachabilityEnabled}.
- */
-class User extends EventEmitter {
-    /**
-     * @internal
-     */
-    constructor(identity, entityName, links, configuration, services) {
-        super();
-        /**
-         * Fired when the properties or the reachability status of the message has been updated.
-         *
-         * Parameters:
-         * 1. object `data` - info object provided with the event. It has the following properties:
-         *     * {@link User} user - the user in question
-         *     * {@link UserUpdateReason}[] updateReasons - array of reasons for the update
-         * @event
-         */
-        this.updated = 'updated';
-        /**
-         * Fired when the client has subscribed to the user.
-         *
-         * Parameters:
-         * 1. {@link User} `user` - the user in question
-         * @event
-         */
-        this.userSubscribed = 'userSubscribed';
-        /**
-         * Fired when the client has unsubscribed from the user.
-         *
-         * Parameters:
-         * 1. {@link User} `user` - the user in question
-         * @event
-         */
-        this.userUnsubscribed = 'userUnsubscribed';
-        this.links = links;
-        this.configuration = configuration;
-        this.services = services;
-        this.subscribed = 'initializing';
-        this.setMaxListeners(0);
-        this.state = {
-            identity,
-            entityName,
-            friendlyName: null,
-            attributes: {},
-            online: null,
-            notifiable: null
-        };
-    }
-    /**
-     * User identity.
-     */
-    get identity() { return this.state.identity; }
-    set identity(identity) { this.state.identity = identity; }
-    set entityName(name) { this.state.entityName = name; }
-    /**
-     * Custom attributes of the user.
-     */
-    get attributes() { return this.state.attributes; }
-    /**
-     * Friendly name of the user, null if not set.
-     */
-    get friendlyName() { return this.state.friendlyName; }
-    /**
-     * Status of the real-time conversation connection of the user.
-     */
-    get isOnline() { return this.state.online; }
-    /**
-     * User push notification registration status.
-     */
-    get isNotifiable() { return this.state.notifiable; }
-    /**
-     * True if this user is receiving real-time status updates.
-     */
-    get isSubscribed() { return this.subscribed == 'subscribed'; }
-    // Handles service updates
-    _update(key, value) {
-        let updateReasons = [];
-        log$2.debug('User for', this.state.identity, 'updated:', key, value);
-        switch (key) {
-            case 'friendlyName':
-                if (this.state.friendlyName !== value.value) {
-                    updateReasons.push('friendlyName');
-                    this.state.friendlyName = value.value;
-                }
-                break;
-            case 'attributes':
-                const updateAttributes = parseAttributes(value.value, `Retrieved malformed attributes from the server for user: ${this.state.identity}`, log$2);
-                if (!isDeepEqual(this.state.attributes, updateAttributes)) {
-                    this.state.attributes = updateAttributes;
-                    updateReasons.push('attributes');
-                }
-                break;
-            case 'reachability':
-                if (this.state.online !== value.online) {
-                    this.state.online = value.online;
-                    updateReasons.push('reachabilityOnline');
-                }
-                if (this.state.notifiable !== value.notifiable) {
-                    this.state.notifiable = value.notifiable;
-                    updateReasons.push('reachabilityNotifiable');
-                }
-                break;
-            default:
-                return;
-        }
-        if (updateReasons.length > 0) {
-            this.emit('updated', { user: this, updateReasons: updateReasons });
-        }
-    }
-    // Fetch reachability info
-    async _updateReachabilityInfo(map, update) {
-        if (!this.configuration.reachabilityEnabled) {
-            return Promise.resolve();
-        }
-        return map.get('reachability')
-            .then(update)
-            .catch(err => { log$2.warn('Failed to get reachability info for ', this.state.identity, err); });
-    }
-    // Fetch user
-    async _fetch() {
-        if (!this.state.entityName) {
-            return this;
-        }
-        this.promiseToFetch = this.services.syncClient.map({ id: this.state.entityName, mode: 'open_existing', includeItems: true })
-            .then(map => {
-            this.entity = map;
-            map.on('itemUpdated', args => {
-                log$2.debug(this.state.entityName + ' (' + this.state.identity + ') itemUpdated: ' + args.item.key);
-                return this._update(args.item.key, args.item.data);
-            });
-            return Promise.all([
-                map.get('friendlyName')
-                    .then(item => this._update(item.key, item.data)),
-                map.get('attributes')
-                    .then(item => this._update(item.key, item.data)),
-                this._updateReachabilityInfo(map, item => this._update(item.key, item.data))
-            ]);
-        })
-            .then(() => {
-            log$2.debug('Fetched for', this.identity);
-            this.subscribed = 'subscribed';
-            this.emit('userSubscribed', this);
-            return this;
-        })
-            .catch(err => {
-            this.promiseToFetch = null;
-            throw err;
-        });
-        return this.promiseToFetch;
-    }
-    _ensureFetched() {
-        return this.promiseToFetch || this._fetch();
-    }
-    /**
-     * Edit user attributes.
-     * @param attributes New attributes.
-     */
-    async updateAttributes(attributes) {
-        if (this.subscribed == 'unsubscribed') {
-            throw new Error('Can\'t modify unsubscribed object');
-        }
-        await this.services.commandExecutor.mutateResource('post', this.links.self, {
-            attributes: JSON.stringify(attributes)
-        });
-        return this;
-    }
-    /**
-     * Update the friendly name of the user.
-     * @param friendlyName New friendly name.
-     */
-    async updateFriendlyName(friendlyName) {
-        if (this.subscribed == 'unsubscribed') {
-            throw new Error('Can\'t modify unsubscribed object');
-        }
-        await this.services.commandExecutor.mutateResource('post', this.links.self, {
-            friendly_name: friendlyName
-        });
-        return this;
-    }
-    /**
-     * Remove the user from the subscription list.
-     * @return A promise of completion.
-     */
-    async unsubscribe() {
-        if (this.promiseToFetch) {
-            await this.promiseToFetch;
-            this.entity.close();
-            this.promiseToFetch = null;
-            this.subscribed = 'unsubscribed';
-            this.emit('userUnsubscribed', this);
-        }
-    }
-}
-__decorate([
-    declarativeTypeValidator.validateTypesAsync(['string', 'number', 'boolean', 'object', declarativeTypeValidator.literal(null)]),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [Object]),
-    __metadata("design:returntype", Promise)
-], User.prototype, "updateAttributes", null);
-__decorate([
-    declarativeTypeValidator.validateTypesAsync(['string']),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String]),
-    __metadata("design:returntype", Promise)
-], User.prototype, "updateFriendlyName", null);
-
 /**
- * @classdesc Container for known users
- * @fires Users#userUpdated
+ * Container for known users
  */
-class Users extends EventEmitter {
-    constructor(configuration, services) {
+class Users extends replayEventEmitter.ReplayEventEmitter {
+    constructor(myself, configuration, services) {
         super();
-        const links = {
-            self: `${configuration.links.users}/${configuration.userIdentity}`
-        };
         this.configuration = configuration;
         this.services = services;
         this.fifoStack = [];
-        this.myself = new User(this.configuration.userIdentity, this.configuration.userInfo, links, this.configuration, this.services);
+        this.myself = myself;
         this.myself.on('updated', (args) => this.emit('userUpdated', args));
         this.myself.on('userSubscribed', () => this.emit('userSubscribed', this.myself));
         this.myself.on('userUnsubscribed', () => {
@@ -3490,10 +3091,7 @@ class Users extends EventEmitter {
             if (!entityName) {
                 entityName = await this.getSyncUniqueName(identity);
             }
-            const links = {
-                self: `${this.configuration.links.users}/${identity}`
-            };
-            user = new User(identity, entityName, links, this.configuration, this.services);
+            user = new User(identity, entityName, this.configuration, this.services);
             user.on('updated', (args) => this.emit('userUpdated', args));
             user.on('userSubscribed', () => this.handleSubscribeUser(user));
             user.on('userUnsubscribed', () => this.handleUnsubscribeUser(user));
@@ -3638,7 +3236,7 @@ class PushNotification {
     }
 }
 
-var version = "2.0.0-rc.1";
+var version = "2.0.0-rc.3";
 
 const trimSlashes = (url) => url.replace(/(^\/+|\/+$)/g, '');
 const isMutationConflictResponse = (response) => response.status.code === 202;
@@ -3714,7 +3312,7 @@ class ClientServices {
 /**
  * A client is the starting point to the Twilio Conversations functionality.
  */
-exports.Client = Client_1 = class Client extends EventEmitter {
+exports.Client = Client_1 = class Client extends replayEventEmitter.ReplayEventEmitter {
     /**
      * Returned Conversations instance is not yet fully initialized. Calling any operations will block until it is.
      * Use connection events to monitor when client becomes fully available (connectionStateChanged with state
@@ -3773,6 +3371,7 @@ exports.Client = Client_1 = class Client extends EventEmitter {
             throw new Error('A valid Twilio token should be provided');
         }
         this.services = new ClientServices();
+        this._myself = new User('', '', null, this.services);
         const startTwilsock = !this.options.twilsockClient;
         // Create default init registrations if none were provided.
         // Otherwise, the outside party have to list all the init registrations they
@@ -3868,13 +3467,23 @@ exports.Client = Client_1 = class Client extends EventEmitter {
         return client;
     }
     /**
-     * Information of the logged-in user.
+     * Information of the logged-in user. Before client initialization, returns an
+     * uninitialized user. Will trigger a {@link Client.userUpdated} event after
+     * initialization.
      */
-    get user() { return this.services.users.myself; }
+    get user() { return this._myself; }
     /**
-     * Client reachability state.
+     * Client reachability state. Throws if accessed before the client
+     * initialization was completed.
      */
-    get reachabilityEnabled() { return this.configuration.reachabilityEnabled; }
+    get reachabilityEnabled() {
+        if (!this.configuration) {
+            throw new Error('Reachability information could not yet be accessed as the client ' +
+                "has not yet been initialized. Subscribe to the 'stateChanged' event " +
+                'to properly react to the client initialization.');
+        }
+        return this.configuration.reachabilityEnabled;
+    }
     get token() { return this.fpaToken; }
     _subscribeToPushNotifications(channelType) {
         [NotificationTypes.NEW_MESSAGE,
@@ -3899,9 +3508,10 @@ exports.Client = Client_1 = class Client extends EventEmitter {
     async _initialize() {
         const configurationResponse = await this.services.commandExecutor.fetchResource('Client/v2/Configuration');
         this.configuration = new Configuration(this.options, configurationResponse, log);
+        this._myself._resolveInitialization(this.configuration, this.configuration.userIdentity, this.configuration.userInfo, true);
         this.services.typingIndicator = new TypingIndicator(this.getConversationBySid.bind(this), this.configuration, this.services);
         this.services.network = new Network(this.configuration, this.services);
-        this.services.users = new Users(this.configuration, this.services);
+        this.services.users = new Users(this._myself, this.configuration, this.services);
         this.services.users.on('userSubscribed', this.emit.bind(this, 'userSubscribed'));
         this.services.users.on('userUpdated', (args) => this.emit('userUpdated', args));
         this.services.users.on('userUnsubscribed', this.emit.bind(this, 'userUnsubscribed'));
@@ -4007,6 +3617,7 @@ exports.Client = Client_1 = class Client extends EventEmitter {
      */
     async setPushRegistrationId(channelType, registrationId) {
         await this._ensureReady;
+        this._subscribeToPushNotifications(channelType);
         this.services.notificationClient.setPushRegistrationId(channelType, registrationId);
         await this.services.notificationClient.commitChanges(); // Committing before this point is useless because we have no push id
     }
@@ -4173,7 +3784,7 @@ exports.Client.conversationLeft = 'conversationLeft';
 exports.Client.conversationRemoved = 'conversationRemoved';
 /**
  * Fired when the attributes or the metadata of a conversation have been updated.
- * During conversation's {@link Client.create| creation and initialization}, this event might be fired multiple times
+ * During conversation's creation and initialization, this event might be fired multiple times
  * for same joined or created conversation as new data is arriving from different sources.
  *
  * Parameters:
@@ -4183,14 +3794,6 @@ exports.Client.conversationRemoved = 'conversationRemoved';
  * @event
  */
 exports.Client.conversationUpdated = 'conversationUpdated';
-/**
- * Fired when the connection state of the client has been changed.
- *
- * Parameters:
- * 1. {@link Conversation} `conversation` - the conversation in question
- * @event
- */
-exports.Client.conversationStateChanged = 'connectionStateChanged';
 /**
  * Fired when a participant has joined a conversation.
  *
@@ -4245,6 +3848,8 @@ exports.Client.messageRemoved = 'messageRemoved';
 exports.Client.messageUpdated = 'messageUpdated';
 /**
  * Fired when the token is about to expire and needs to be updated.
+ * * Parameters:
+ * 1. number `message` - token's time to live
  * @event
  */
 exports.Client.tokenAboutToExpire = 'tokenAboutToExpire';
@@ -4303,6 +3908,22 @@ exports.Client.userUnsubscribed = 'userUnsubscribed';
  * @event
  */
 exports.Client.userUpdated = 'userUpdated';
+/**
+ * Fired when the state of the client has been changed.
+ *
+ * Parameters:
+ * 1. {@link State} `state` - the new client state
+ * @event
+ */
+exports.Client.stateChanged = 'stateChanged';
+/**
+ * Fired when the connection state of the client has been changed.
+ *
+ * Paremeters:
+ * 1. {@link ConnectionState} `state` - the new connection state
+ * @event
+ */
+exports.Client.connectionStateChanged = 'connectionStateChanged';
 /**
  * Fired when the connection is interrupted for an unexpected reason.
  *
@@ -4391,22 +4012,20 @@ __decorate([
 exports.Client = Client_1 = __decorate([
     declarativeTypeValidator.validateConstructorTypes(declarativeTypeValidator.nonEmptyString, [
         declarativeTypeValidator.pureObject,
-        'undefined',
-        declarativeTypeValidator.literal(null),
+        'undefined'
     ]),
     __metadata("design:paramtypes", [String, Object])
 ], exports.Client);
 
-var Client = exports.Client;
-
 exports.AggregatedDeliveryReceipt = AggregatedDeliveryReceipt;
 exports.Conversation = Conversation;
 exports.DetailedDeliveryReceipt = DetailedDeliveryReceipt;
 exports.Media = Media;
 exports.Message = Message;
+exports.MessageBuilder = MessageBuilder;
 exports.Participant = Participant;
 exports.PushNotification = PushNotification;
 exports.RestPaginator = RestPaginator;
+exports.UnsentMessage = UnsentMessage;
 exports.User = User;
-exports.default = Client;
 //# sourceMappingURL=react-native.js.map