@wireapp/protocol-messaging 1.60.0 → 1.61.0

package/web/otr.js

@@ -38,7 +38,7 @@ $root.proteus = (function() {
         function UserId(properties) {
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -71,9 +71,13 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        UserId.encode = function encode(message, writer) {
+        UserId.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             writer.uint32(/* id 1, wireType 2 =*/10).bytes(message.uuid);
             return writer;
         };
@@ -102,23 +106,29 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        UserId.decode = function decode(reader, length) {
+        UserId.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.UserId();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
                         message.uuid = reader.bytes();
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("uuid"))
+            if (!Object.hasOwnProperty.call(message, "uuid"))
                 throw $util.ProtocolError("missing required 'uuid'", { instance: message });
             return message;
         };
@@ -147,9 +157,13 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        UserId.verify = function verify(message) {
+        UserId.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             if (!(message.uuid && typeof message.uuid.length === "number" || $util.isString(message.uuid)))
                 return "uuid: buffer expected";
             return null;
@@ -163,9 +177,15 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.UserId} UserId
          */
-        UserId.fromObject = function fromObject(object) {
+        UserId.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.UserId)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.UserId: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.UserId();
             if (object.uuid != null)
                 if (typeof object.uuid === "string")
@@ -184,9 +204,13 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        UserId.toObject = function toObject(message, options) {
+        UserId.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.defaults)
                 if (options.bytes === String)
@@ -196,7 +220,7 @@ $root.proteus = (function() {
                     if (options.bytes !== Array)
                         object.uuid = $util.newBuffer(object.uuid);
                 }
-            if (message.uuid != null && message.hasOwnProperty("uuid"))
+            if (message.uuid != null && Object.hasOwnProperty.call(message, "uuid"))
                 object.uuid = options.bytes === String ? $util.base64.encode(message.uuid, 0, message.uuid.length) : options.bytes === Array ? Array.prototype.slice.call(message.uuid) : message.uuid;
             return object;
         };
@@ -251,7 +275,7 @@ $root.proteus = (function() {
         function QualifiedUserId(properties) {
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -292,9 +316,13 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        QualifiedUserId.encode = function encode(message, writer) {
+        QualifiedUserId.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             writer.uint32(/* id 1, wireType 2 =*/10).string(message.id);
             writer.uint32(/* id 2, wireType 2 =*/18).string(message.domain);
             return writer;
@@ -324,12 +352,18 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        QualifiedUserId.decode = function decode(reader, length) {
+        QualifiedUserId.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.QualifiedUserId();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
                         message.id = reader.string();
@@ -340,13 +374,13 @@ $root.proteus = (function() {
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("id"))
+            if (!Object.hasOwnProperty.call(message, "id"))
                 throw $util.ProtocolError("missing required 'id'", { instance: message });
-            if (!message.hasOwnProperty("domain"))
+            if (!Object.hasOwnProperty.call(message, "domain"))
                 throw $util.ProtocolError("missing required 'domain'", { instance: message });
             return message;
         };
@@ -375,9 +409,13 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        QualifiedUserId.verify = function verify(message) {
+        QualifiedUserId.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             if (!$util.isString(message.id))
                 return "id: string expected";
             if (!$util.isString(message.domain))
@@ -393,9 +431,15 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.QualifiedUserId} QualifiedUserId
          */
-        QualifiedUserId.fromObject = function fromObject(object) {
+        QualifiedUserId.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.QualifiedUserId)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.QualifiedUserId: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.QualifiedUserId();
             if (object.id != null)
                 message.id = String(object.id);
@@ -413,17 +457,21 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        QualifiedUserId.toObject = function toObject(message, options) {
+        QualifiedUserId.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.defaults) {
                 object.id = "";
                 object.domain = "";
             }
-            if (message.id != null && message.hasOwnProperty("id"))
+            if (message.id != null && Object.hasOwnProperty.call(message, "id"))
                 object.id = message.id;
-            if (message.domain != null && message.hasOwnProperty("domain"))
+            if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
                 object.domain = message.domain;
             return object;
         };
@@ -477,7 +525,7 @@ $root.proteus = (function() {
         function ClientId(properties) {
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -510,9 +558,13 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        ClientId.encode = function encode(message, writer) {
+        ClientId.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             writer.uint32(/* id 1, wireType 0 =*/8).uint64(message.client);
             return writer;
         };
@@ -541,23 +593,29 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        ClientId.decode = function decode(reader, length) {
+        ClientId.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientId();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
                         message.client = reader.uint64();
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("client"))
+            if (!Object.hasOwnProperty.call(message, "client"))
                 throw $util.ProtocolError("missing required 'client'", { instance: message });
             return message;
         };
@@ -586,9 +644,13 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        ClientId.verify = function verify(message) {
+        ClientId.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             if (!$util.isInteger(message.client) && !(message.client && $util.isInteger(message.client.low) && $util.isInteger(message.client.high)))
                 return "client: integer|Long expected";
             return null;
@@ -602,13 +664,19 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.ClientId} ClientId
          */
-        ClientId.fromObject = function fromObject(object) {
+        ClientId.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.ClientId)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.ClientId: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.ClientId();
             if (object.client != null)
                 if ($util.Long)
-                    (message.client = $util.Long.fromValue(object.client)).unsigned = true;
+                    message.client = $util.Long.fromValue(object.client, true);
                 else if (typeof object.client === "string")
                     message.client = parseInt(object.client, 10);
                 else if (typeof object.client === "number")
@@ -627,18 +695,24 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        ClientId.toObject = function toObject(message, options) {
+        ClientId.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.defaults)
                 if ($util.Long) {
                     var long = new $util.Long(0, 0, true);
-                    object.client = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : long;
+                    object.client = options.longs === String ? long.toString() : options.longs === Number ? long.toNumber() : typeof BigInt !== "undefined" && options.longs === BigInt ? long.toBigInt() : long;
                 } else
-                    object.client = options.longs === String ? "0" : 0;
-            if (message.client != null && message.hasOwnProperty("client"))
-                if (typeof message.client === "number")
+                    object.client = options.longs === String ? "0" : typeof BigInt !== "undefined" && options.longs === BigInt ? BigInt("0") : 0;
+            if (message.client != null && Object.hasOwnProperty.call(message, "client"))
+                if (typeof BigInt !== "undefined" && options.longs === BigInt)
+                    object.client = typeof message.client === "number" ? BigInt(message.client) : $util.Long.fromBits(message.client.low >>> 0, message.client.high >>> 0, true).toBigInt();
+                else if (typeof message.client === "number")
                     object.client = options.longs === String ? String(message.client) : message.client;
                 else
                     object.client = options.longs === String ? $util.Long.prototype.toString.call(message.client) : options.longs === Number ? new $util.LongBits(message.client.low >>> 0, message.client.high >>> 0).toNumber(true) : message.client;
@@ -695,7 +769,7 @@ $root.proteus = (function() {
         function ClientEntry(properties) {
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -736,10 +810,14 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        ClientEntry.encode = function encode(message, writer) {
+        ClientEntry.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
-            $root.proteus.ClientId.encode(message.client, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            $root.proteus.ClientId.encode(message.client, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
             writer.uint32(/* id 2, wireType 2 =*/18).bytes(message.text);
             return writer;
         };
@@ -768,15 +846,21 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        ClientEntry.decode = function decode(reader, length) {
+        ClientEntry.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientEntry();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
-                        message.client = $root.proteus.ClientId.decode(reader, reader.uint32());
+                        message.client = $root.proteus.ClientId.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 2: {
@@ -784,13 +868,13 @@ $root.proteus = (function() {
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("client"))
+            if (!Object.hasOwnProperty.call(message, "client"))
                 throw $util.ProtocolError("missing required 'client'", { instance: message });
-            if (!message.hasOwnProperty("text"))
+            if (!Object.hasOwnProperty.call(message, "text"))
                 throw $util.ProtocolError("missing required 'text'", { instance: message });
             return message;
         };
@@ -819,11 +903,15 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        ClientEntry.verify = function verify(message) {
+        ClientEntry.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             {
-                var error = $root.proteus.ClientId.verify(message.client);
+                var error = $root.proteus.ClientId.verify(message.client, long + 1);
                 if (error)
                     return "client." + error;
             }
@@ -840,14 +928,20 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.ClientEntry} ClientEntry
          */
-        ClientEntry.fromObject = function fromObject(object) {
+        ClientEntry.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.ClientEntry)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.ClientEntry: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.ClientEntry();
             if (object.client != null) {
-                if (typeof object.client !== "object")
+                if (!$util.isObject(object.client))
                     throw TypeError(".proteus.ClientEntry.client: object expected");
-                message.client = $root.proteus.ClientId.fromObject(object.client);
+                message.client = $root.proteus.ClientId.fromObject(object.client, long + 1);
             }
             if (object.text != null)
                 if (typeof object.text === "string")
@@ -866,9 +960,13 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        ClientEntry.toObject = function toObject(message, options) {
+        ClientEntry.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.defaults) {
                 object.client = null;
@@ -880,9 +978,9 @@ $root.proteus = (function() {
                         object.text = $util.newBuffer(object.text);
                 }
             }
-            if (message.client != null && message.hasOwnProperty("client"))
-                object.client = $root.proteus.ClientId.toObject(message.client, options);
-            if (message.text != null && message.hasOwnProperty("text"))
+            if (message.client != null && Object.hasOwnProperty.call(message, "client"))
+                object.client = $root.proteus.ClientId.toObject(message.client, options, q + 1);
+            if (message.text != null && Object.hasOwnProperty.call(message, "text"))
                 object.text = options.bytes === String ? $util.base64.encode(message.text, 0, message.text.length) : options.bytes === Array ? Array.prototype.slice.call(message.text) : message.text;
             return object;
         };
@@ -938,7 +1036,7 @@ $root.proteus = (function() {
             this.clients = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -979,13 +1077,17 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        UserEntry.encode = function encode(message, writer) {
+        UserEntry.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
-            $root.proteus.UserId.encode(message.user, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            $root.proteus.UserId.encode(message.user, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
             if (message.clients != null && message.clients.length)
                 for (var i = 0; i < message.clients.length; ++i)
-                    $root.proteus.ClientEntry.encode(message.clients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    $root.proteus.ClientEntry.encode(message.clients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim();
             return writer;
         };
 
@@ -1013,29 +1115,35 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        UserEntry.decode = function decode(reader, length) {
+        UserEntry.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.UserEntry();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
-                        message.user = $root.proteus.UserId.decode(reader, reader.uint32());
+                        message.user = $root.proteus.UserId.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 2: {
                         if (!(message.clients && message.clients.length))
                             message.clients = [];
-                        message.clients.push($root.proteus.ClientEntry.decode(reader, reader.uint32()));
+                        message.clients.push($root.proteus.ClientEntry.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("user"))
+            if (!Object.hasOwnProperty.call(message, "user"))
                 throw $util.ProtocolError("missing required 'user'", { instance: message });
             return message;
         };
@@ -1064,19 +1172,23 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        UserEntry.verify = function verify(message) {
+        UserEntry.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             {
-                var error = $root.proteus.UserId.verify(message.user);
+                var error = $root.proteus.UserId.verify(message.user, long + 1);
                 if (error)
                     return "user." + error;
             }
-            if (message.clients != null && message.hasOwnProperty("clients")) {
+            if (message.clients != null && Object.hasOwnProperty.call(message, "clients")) {
                 if (!Array.isArray(message.clients))
                     return "clients: array expected";
                 for (var i = 0; i < message.clients.length; ++i) {
-                    var error = $root.proteus.ClientEntry.verify(message.clients[i]);
+                    var error = $root.proteus.ClientEntry.verify(message.clients[i], long + 1);
                     if (error)
                         return "clients." + error;
                 }
@@ -1092,23 +1204,29 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.UserEntry} UserEntry
          */
-        UserEntry.fromObject = function fromObject(object) {
+        UserEntry.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.UserEntry)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.UserEntry: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.UserEntry();
             if (object.user != null) {
-                if (typeof object.user !== "object")
+                if (!$util.isObject(object.user))
                     throw TypeError(".proteus.UserEntry.user: object expected");
-                message.user = $root.proteus.UserId.fromObject(object.user);
+                message.user = $root.proteus.UserId.fromObject(object.user, long + 1);
             }
             if (object.clients) {
                 if (!Array.isArray(object.clients))
                     throw TypeError(".proteus.UserEntry.clients: array expected");
                 message.clients = [];
                 for (var i = 0; i < object.clients.length; ++i) {
-                    if (typeof object.clients[i] !== "object")
+                    if (!$util.isObject(object.clients[i]))
                         throw TypeError(".proteus.UserEntry.clients: object expected");
-                    message.clients[i] = $root.proteus.ClientEntry.fromObject(object.clients[i]);
+                    message.clients[i] = $root.proteus.ClientEntry.fromObject(object.clients[i], long + 1);
                 }
             }
             return message;
@@ -1123,20 +1241,24 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        UserEntry.toObject = function toObject(message, options) {
+        UserEntry.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.arrays || options.defaults)
                 object.clients = [];
             if (options.defaults)
                 object.user = null;
-            if (message.user != null && message.hasOwnProperty("user"))
-                object.user = $root.proteus.UserId.toObject(message.user, options);
+            if (message.user != null && Object.hasOwnProperty.call(message, "user"))
+                object.user = $root.proteus.UserId.toObject(message.user, options, q + 1);
             if (message.clients && message.clients.length) {
                 object.clients = [];
                 for (var j = 0; j < message.clients.length; ++j)
-                    object.clients[j] = $root.proteus.ClientEntry.toObject(message.clients[j], options);
+                    object.clients[j] = $root.proteus.ClientEntry.toObject(message.clients[j], options, q + 1);
             }
             return object;
         };
@@ -1192,7 +1314,7 @@ $root.proteus = (function() {
             this.entries = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -1233,13 +1355,17 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        QualifiedUserEntry.encode = function encode(message, writer) {
+        QualifiedUserEntry.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             writer.uint32(/* id 1, wireType 2 =*/10).string(message.domain);
             if (message.entries != null && message.entries.length)
                 for (var i = 0; i < message.entries.length; ++i)
-                    $root.proteus.UserEntry.encode(message.entries[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    $root.proteus.UserEntry.encode(message.entries[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim();
             return writer;
         };
 
@@ -1267,12 +1393,18 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        QualifiedUserEntry.decode = function decode(reader, length) {
+        QualifiedUserEntry.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.QualifiedUserEntry();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
                         message.domain = reader.string();
@@ -1281,15 +1413,15 @@ $root.proteus = (function() {
                 case 2: {
                         if (!(message.entries && message.entries.length))
                             message.entries = [];
-                        message.entries.push($root.proteus.UserEntry.decode(reader, reader.uint32()));
+                        message.entries.push($root.proteus.UserEntry.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("domain"))
+            if (!Object.hasOwnProperty.call(message, "domain"))
                 throw $util.ProtocolError("missing required 'domain'", { instance: message });
             return message;
         };
@@ -1318,16 +1450,20 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        QualifiedUserEntry.verify = function verify(message) {
+        QualifiedUserEntry.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             if (!$util.isString(message.domain))
                 return "domain: string expected";
-            if (message.entries != null && message.hasOwnProperty("entries")) {
+            if (message.entries != null && Object.hasOwnProperty.call(message, "entries")) {
                 if (!Array.isArray(message.entries))
                     return "entries: array expected";
                 for (var i = 0; i < message.entries.length; ++i) {
-                    var error = $root.proteus.UserEntry.verify(message.entries[i]);
+                    var error = $root.proteus.UserEntry.verify(message.entries[i], long + 1);
                     if (error)
                         return "entries." + error;
                 }
@@ -1343,9 +1479,15 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.QualifiedUserEntry} QualifiedUserEntry
          */
-        QualifiedUserEntry.fromObject = function fromObject(object) {
+        QualifiedUserEntry.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.QualifiedUserEntry)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.QualifiedUserEntry: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.QualifiedUserEntry();
             if (object.domain != null)
                 message.domain = String(object.domain);
@@ -1354,9 +1496,9 @@ $root.proteus = (function() {
                     throw TypeError(".proteus.QualifiedUserEntry.entries: array expected");
                 message.entries = [];
                 for (var i = 0; i < object.entries.length; ++i) {
-                    if (typeof object.entries[i] !== "object")
+                    if (!$util.isObject(object.entries[i]))
                         throw TypeError(".proteus.QualifiedUserEntry.entries: object expected");
-                    message.entries[i] = $root.proteus.UserEntry.fromObject(object.entries[i]);
+                    message.entries[i] = $root.proteus.UserEntry.fromObject(object.entries[i], long + 1);
                 }
             }
             return message;
@@ -1371,20 +1513,24 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        QualifiedUserEntry.toObject = function toObject(message, options) {
+        QualifiedUserEntry.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.arrays || options.defaults)
                 object.entries = [];
             if (options.defaults)
                 object.domain = "";
-            if (message.domain != null && message.hasOwnProperty("domain"))
+            if (message.domain != null && Object.hasOwnProperty.call(message, "domain"))
                 object.domain = message.domain;
             if (message.entries && message.entries.length) {
                 object.entries = [];
                 for (var j = 0; j < message.entries.length; ++j)
-                    object.entries[j] = $root.proteus.UserEntry.toObject(message.entries[j], options);
+                    object.entries[j] = $root.proteus.UserEntry.toObject(message.entries[j], options, q + 1);
             }
             return object;
         };
@@ -1460,7 +1606,7 @@ $root.proteus = (function() {
             this.reportMissing = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -1541,13 +1687,17 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        NewOtrMessage.encode = function encode(message, writer) {
+        NewOtrMessage.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
-            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
             if (message.recipients != null && message.recipients.length)
                 for (var i = 0; i < message.recipients.length; ++i)
-                    $root.proteus.UserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    $root.proteus.UserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim();
             if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 writer.uint32(/* id 3, wireType 0 =*/24).bool(message.nativePush);
             if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
@@ -1558,7 +1708,7 @@ $root.proteus = (function() {
                 writer.uint32(/* id 6, wireType 0 =*/48).bool(message.transient);
             if (message.reportMissing != null && message.reportMissing.length)
                 for (var i = 0; i < message.reportMissing.length; ++i)
-                    $root.proteus.UserId.encode(message.reportMissing[i], writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
+                    $root.proteus.UserId.encode(message.reportMissing[i], writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim();
             return writer;
         };
 
@@ -1586,21 +1736,27 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        NewOtrMessage.decode = function decode(reader, length) {
+        NewOtrMessage.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.NewOtrMessage();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
-                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32());
+                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 2: {
                         if (!(message.recipients && message.recipients.length))
                             message.recipients = [];
-                        message.recipients.push($root.proteus.UserEntry.decode(reader, reader.uint32()));
+                        message.recipients.push($root.proteus.UserEntry.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 case 3: {
@@ -1622,15 +1778,15 @@ $root.proteus = (function() {
                 case 7: {
                         if (!(message.reportMissing && message.reportMissing.length))
                             message.reportMissing = [];
-                        message.reportMissing.push($root.proteus.UserId.decode(reader, reader.uint32()));
+                        message.reportMissing.push($root.proteus.UserId.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("sender"))
+            if (!Object.hasOwnProperty.call(message, "sender"))
                 throw $util.ProtocolError("missing required 'sender'", { instance: message });
             return message;
         };
@@ -1659,30 +1815,34 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        NewOtrMessage.verify = function verify(message) {
+        NewOtrMessage.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             {
-                var error = $root.proteus.ClientId.verify(message.sender);
+                var error = $root.proteus.ClientId.verify(message.sender, long + 1);
                 if (error)
                     return "sender." + error;
             }
-            if (message.recipients != null && message.hasOwnProperty("recipients")) {
+            if (message.recipients != null && Object.hasOwnProperty.call(message, "recipients")) {
                 if (!Array.isArray(message.recipients))
                     return "recipients: array expected";
                 for (var i = 0; i < message.recipients.length; ++i) {
-                    var error = $root.proteus.UserEntry.verify(message.recipients[i]);
+                    var error = $root.proteus.UserEntry.verify(message.recipients[i], long + 1);
                     if (error)
                         return "recipients." + error;
                 }
             }
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 if (typeof message.nativePush !== "boolean")
                     return "nativePush: boolean expected";
-            if (message.blob != null && message.hasOwnProperty("blob"))
+            if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
                 if (!(message.blob && typeof message.blob.length === "number" || $util.isString(message.blob)))
                     return "blob: buffer expected";
-            if (message.nativePriority != null && message.hasOwnProperty("nativePriority"))
+            if (message.nativePriority != null && Object.hasOwnProperty.call(message, "nativePriority"))
                 switch (message.nativePriority) {
                 default:
                     return "nativePriority: enum value expected";
@@ -1690,14 +1850,14 @@ $root.proteus = (function() {
                 case 2:
                     break;
                 }
-            if (message.transient != null && message.hasOwnProperty("transient"))
+            if (message.transient != null && Object.hasOwnProperty.call(message, "transient"))
                 if (typeof message.transient !== "boolean")
                     return "transient: boolean expected";
-            if (message.reportMissing != null && message.hasOwnProperty("reportMissing")) {
+            if (message.reportMissing != null && Object.hasOwnProperty.call(message, "reportMissing")) {
                 if (!Array.isArray(message.reportMissing))
                     return "reportMissing: array expected";
                 for (var i = 0; i < message.reportMissing.length; ++i) {
-                    var error = $root.proteus.UserId.verify(message.reportMissing[i]);
+                    var error = $root.proteus.UserId.verify(message.reportMissing[i], long + 1);
                     if (error)
                         return "reportMissing." + error;
                 }
@@ -1713,23 +1873,29 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.NewOtrMessage} NewOtrMessage
          */
-        NewOtrMessage.fromObject = function fromObject(object) {
+        NewOtrMessage.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.NewOtrMessage)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.NewOtrMessage: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.NewOtrMessage();
             if (object.sender != null) {
-                if (typeof object.sender !== "object")
+                if (!$util.isObject(object.sender))
                     throw TypeError(".proteus.NewOtrMessage.sender: object expected");
-                message.sender = $root.proteus.ClientId.fromObject(object.sender);
+                message.sender = $root.proteus.ClientId.fromObject(object.sender, long + 1);
             }
             if (object.recipients) {
                 if (!Array.isArray(object.recipients))
                     throw TypeError(".proteus.NewOtrMessage.recipients: array expected");
                 message.recipients = [];
                 for (var i = 0; i < object.recipients.length; ++i) {
-                    if (typeof object.recipients[i] !== "object")
+                    if (!$util.isObject(object.recipients[i]))
                         throw TypeError(".proteus.NewOtrMessage.recipients: object expected");
-                    message.recipients[i] = $root.proteus.UserEntry.fromObject(object.recipients[i]);
+                    message.recipients[i] = $root.proteus.UserEntry.fromObject(object.recipients[i], long + 1);
                 }
             }
             if (object.nativePush != null)
@@ -1762,9 +1928,9 @@ $root.proteus = (function() {
                     throw TypeError(".proteus.NewOtrMessage.reportMissing: array expected");
                 message.reportMissing = [];
                 for (var i = 0; i < object.reportMissing.length; ++i) {
-                    if (typeof object.reportMissing[i] !== "object")
+                    if (!$util.isObject(object.reportMissing[i]))
                         throw TypeError(".proteus.NewOtrMessage.reportMissing: object expected");
-                    message.reportMissing[i] = $root.proteus.UserId.fromObject(object.reportMissing[i]);
+                    message.reportMissing[i] = $root.proteus.UserId.fromObject(object.reportMissing[i], long + 1);
                 }
             }
             return message;
@@ -1779,9 +1945,13 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        NewOtrMessage.toObject = function toObject(message, options) {
+        NewOtrMessage.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.arrays || options.defaults) {
                 object.recipients = [];
@@ -1800,25 +1970,25 @@ $root.proteus = (function() {
                 object.nativePriority = options.enums === String ? "LOW_PRIORITY" : 1;
                 object.transient = false;
             }
-            if (message.sender != null && message.hasOwnProperty("sender"))
-                object.sender = $root.proteus.ClientId.toObject(message.sender, options);
+            if (message.sender != null && Object.hasOwnProperty.call(message, "sender"))
+                object.sender = $root.proteus.ClientId.toObject(message.sender, options, q + 1);
             if (message.recipients && message.recipients.length) {
                 object.recipients = [];
                 for (var j = 0; j < message.recipients.length; ++j)
-                    object.recipients[j] = $root.proteus.UserEntry.toObject(message.recipients[j], options);
+                    object.recipients[j] = $root.proteus.UserEntry.toObject(message.recipients[j], options, q + 1);
             }
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 object.nativePush = message.nativePush;
-            if (message.blob != null && message.hasOwnProperty("blob"))
+            if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
                 object.blob = options.bytes === String ? $util.base64.encode(message.blob, 0, message.blob.length) : options.bytes === Array ? Array.prototype.slice.call(message.blob) : message.blob;
-            if (message.nativePriority != null && message.hasOwnProperty("nativePriority"))
+            if (message.nativePriority != null && Object.hasOwnProperty.call(message, "nativePriority"))
                 object.nativePriority = options.enums === String ? $root.proteus.Priority[message.nativePriority] === undefined ? message.nativePriority : $root.proteus.Priority[message.nativePriority] : message.nativePriority;
-            if (message.transient != null && message.hasOwnProperty("transient"))
+            if (message.transient != null && Object.hasOwnProperty.call(message, "transient"))
                 object.transient = message.transient;
             if (message.reportMissing && message.reportMissing.length) {
                 object.reportMissing = [];
                 for (var j = 0; j < message.reportMissing.length; ++j)
-                    object.reportMissing[j] = $root.proteus.UserId.toObject(message.reportMissing[j], options);
+                    object.reportMissing[j] = $root.proteus.UserId.toObject(message.reportMissing[j], options, q + 1);
             }
             return object;
         };
@@ -1882,7 +2052,7 @@ $root.proteus = (function() {
             this.recipients = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -2001,13 +2171,17 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        QualifiedNewOtrMessage.encode = function encode(message, writer) {
+        QualifiedNewOtrMessage.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
-            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
             if (message.recipients != null && message.recipients.length)
                 for (var i = 0; i < message.recipients.length; ++i)
-                    $root.proteus.QualifiedUserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    $root.proteus.QualifiedUserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim();
             if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 writer.uint32(/* id 3, wireType 0 =*/24).bool(message.nativePush);
             if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
@@ -2017,13 +2191,13 @@ $root.proteus = (function() {
             if (message.transient != null && Object.hasOwnProperty.call(message, "transient"))
                 writer.uint32(/* id 6, wireType 0 =*/48).bool(message.transient);
             if (message.reportAll != null && Object.hasOwnProperty.call(message, "reportAll"))
-                $root.proteus.ClientMismatchStrategy.ReportAll.encode(message.reportAll, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
+                $root.proteus.ClientMismatchStrategy.ReportAll.encode(message.reportAll, writer.uint32(/* id 7, wireType 2 =*/58).fork(), q + 1).ldelim();
             if (message.ignoreAll != null && Object.hasOwnProperty.call(message, "ignoreAll"))
-                $root.proteus.ClientMismatchStrategy.IgnoreAll.encode(message.ignoreAll, writer.uint32(/* id 8, wireType 2 =*/66).fork()).ldelim();
+                $root.proteus.ClientMismatchStrategy.IgnoreAll.encode(message.ignoreAll, writer.uint32(/* id 8, wireType 2 =*/66).fork(), q + 1).ldelim();
             if (message.reportOnly != null && Object.hasOwnProperty.call(message, "reportOnly"))
-                $root.proteus.ClientMismatchStrategy.ReportOnly.encode(message.reportOnly, writer.uint32(/* id 9, wireType 2 =*/74).fork()).ldelim();
+                $root.proteus.ClientMismatchStrategy.ReportOnly.encode(message.reportOnly, writer.uint32(/* id 9, wireType 2 =*/74).fork(), q + 1).ldelim();
             if (message.ignoreOnly != null && Object.hasOwnProperty.call(message, "ignoreOnly"))
-                $root.proteus.ClientMismatchStrategy.IgnoreOnly.encode(message.ignoreOnly, writer.uint32(/* id 10, wireType 2 =*/82).fork()).ldelim();
+                $root.proteus.ClientMismatchStrategy.IgnoreOnly.encode(message.ignoreOnly, writer.uint32(/* id 10, wireType 2 =*/82).fork(), q + 1).ldelim();
             return writer;
         };
 
@@ -2051,21 +2225,27 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        QualifiedNewOtrMessage.decode = function decode(reader, length) {
+        QualifiedNewOtrMessage.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.QualifiedNewOtrMessage();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
-                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32());
+                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 2: {
                         if (!(message.recipients && message.recipients.length))
                             message.recipients = [];
-                        message.recipients.push($root.proteus.QualifiedUserEntry.decode(reader, reader.uint32()));
+                        message.recipients.push($root.proteus.QualifiedUserEntry.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 case 3: {
@@ -2085,27 +2265,27 @@ $root.proteus = (function() {
                         break;
                     }
                 case 7: {
-                        message.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.decode(reader, reader.uint32());
+                        message.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 8: {
-                        message.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.decode(reader, reader.uint32());
+                        message.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 9: {
-                        message.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.decode(reader, reader.uint32());
+                        message.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 10: {
-                        message.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.decode(reader, reader.uint32());
+                        message.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("sender"))
+            if (!Object.hasOwnProperty.call(message, "sender"))
                 throw $util.ProtocolError("missing required 'sender'", { instance: message });
             return message;
         };
@@ -2134,31 +2314,35 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        QualifiedNewOtrMessage.verify = function verify(message) {
+        QualifiedNewOtrMessage.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             var properties = {};
             {
-                var error = $root.proteus.ClientId.verify(message.sender);
+                var error = $root.proteus.ClientId.verify(message.sender, long + 1);
                 if (error)
                     return "sender." + error;
             }
-            if (message.recipients != null && message.hasOwnProperty("recipients")) {
+            if (message.recipients != null && Object.hasOwnProperty.call(message, "recipients")) {
                 if (!Array.isArray(message.recipients))
                     return "recipients: array expected";
                 for (var i = 0; i < message.recipients.length; ++i) {
-                    var error = $root.proteus.QualifiedUserEntry.verify(message.recipients[i]);
+                    var error = $root.proteus.QualifiedUserEntry.verify(message.recipients[i], long + 1);
                     if (error)
                         return "recipients." + error;
                 }
             }
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 if (typeof message.nativePush !== "boolean")
                     return "nativePush: boolean expected";
-            if (message.blob != null && message.hasOwnProperty("blob"))
+            if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
                 if (!(message.blob && typeof message.blob.length === "number" || $util.isString(message.blob)))
                     return "blob: buffer expected";
-            if (message.nativePriority != null && message.hasOwnProperty("nativePriority"))
+            if (message.nativePriority != null && Object.hasOwnProperty.call(message, "nativePriority"))
                 switch (message.nativePriority) {
                 default:
                     return "nativePriority: enum value expected";
@@ -2166,43 +2350,43 @@ $root.proteus = (function() {
                 case 2:
                     break;
                 }
-            if (message.transient != null && message.hasOwnProperty("transient"))
+            if (message.transient != null && Object.hasOwnProperty.call(message, "transient"))
                 if (typeof message.transient !== "boolean")
                     return "transient: boolean expected";
-            if (message.reportAll != null && message.hasOwnProperty("reportAll")) {
+            if (message.reportAll != null && Object.hasOwnProperty.call(message, "reportAll")) {
                 properties.clientMismatchStrategy = 1;
                 {
-                    var error = $root.proteus.ClientMismatchStrategy.ReportAll.verify(message.reportAll);
+                    var error = $root.proteus.ClientMismatchStrategy.ReportAll.verify(message.reportAll, long + 1);
                     if (error)
                         return "reportAll." + error;
                 }
             }
-            if (message.ignoreAll != null && message.hasOwnProperty("ignoreAll")) {
+            if (message.ignoreAll != null && Object.hasOwnProperty.call(message, "ignoreAll")) {
                 if (properties.clientMismatchStrategy === 1)
                     return "clientMismatchStrategy: multiple values";
                 properties.clientMismatchStrategy = 1;
                 {
-                    var error = $root.proteus.ClientMismatchStrategy.IgnoreAll.verify(message.ignoreAll);
+                    var error = $root.proteus.ClientMismatchStrategy.IgnoreAll.verify(message.ignoreAll, long + 1);
                     if (error)
                         return "ignoreAll." + error;
                 }
             }
-            if (message.reportOnly != null && message.hasOwnProperty("reportOnly")) {
+            if (message.reportOnly != null && Object.hasOwnProperty.call(message, "reportOnly")) {
                 if (properties.clientMismatchStrategy === 1)
                     return "clientMismatchStrategy: multiple values";
                 properties.clientMismatchStrategy = 1;
                 {
-                    var error = $root.proteus.ClientMismatchStrategy.ReportOnly.verify(message.reportOnly);
+                    var error = $root.proteus.ClientMismatchStrategy.ReportOnly.verify(message.reportOnly, long + 1);
                     if (error)
                         return "reportOnly." + error;
                 }
             }
-            if (message.ignoreOnly != null && message.hasOwnProperty("ignoreOnly")) {
+            if (message.ignoreOnly != null && Object.hasOwnProperty.call(message, "ignoreOnly")) {
                 if (properties.clientMismatchStrategy === 1)
                     return "clientMismatchStrategy: multiple values";
                 properties.clientMismatchStrategy = 1;
                 {
-                    var error = $root.proteus.ClientMismatchStrategy.IgnoreOnly.verify(message.ignoreOnly);
+                    var error = $root.proteus.ClientMismatchStrategy.IgnoreOnly.verify(message.ignoreOnly, long + 1);
                     if (error)
                         return "ignoreOnly." + error;
                 }
@@ -2218,23 +2402,29 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.QualifiedNewOtrMessage} QualifiedNewOtrMessage
          */
-        QualifiedNewOtrMessage.fromObject = function fromObject(object) {
+        QualifiedNewOtrMessage.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.QualifiedNewOtrMessage)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.QualifiedNewOtrMessage: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.QualifiedNewOtrMessage();
             if (object.sender != null) {
-                if (typeof object.sender !== "object")
+                if (!$util.isObject(object.sender))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.sender: object expected");
-                message.sender = $root.proteus.ClientId.fromObject(object.sender);
+                message.sender = $root.proteus.ClientId.fromObject(object.sender, long + 1);
             }
             if (object.recipients) {
                 if (!Array.isArray(object.recipients))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.recipients: array expected");
                 message.recipients = [];
                 for (var i = 0; i < object.recipients.length; ++i) {
-                    if (typeof object.recipients[i] !== "object")
+                    if (!$util.isObject(object.recipients[i]))
                         throw TypeError(".proteus.QualifiedNewOtrMessage.recipients: object expected");
-                    message.recipients[i] = $root.proteus.QualifiedUserEntry.fromObject(object.recipients[i]);
+                    message.recipients[i] = $root.proteus.QualifiedUserEntry.fromObject(object.recipients[i], long + 1);
                 }
             }
             if (object.nativePush != null)
@@ -2263,24 +2453,24 @@ $root.proteus = (function() {
             if (object.transient != null)
                 message.transient = Boolean(object.transient);
             if (object.reportAll != null) {
-                if (typeof object.reportAll !== "object")
+                if (!$util.isObject(object.reportAll))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.reportAll: object expected");
-                message.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.fromObject(object.reportAll);
+                message.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.fromObject(object.reportAll, long + 1);
             }
             if (object.ignoreAll != null) {
-                if (typeof object.ignoreAll !== "object")
+                if (!$util.isObject(object.ignoreAll))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.ignoreAll: object expected");
-                message.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.fromObject(object.ignoreAll);
+                message.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.fromObject(object.ignoreAll, long + 1);
             }
             if (object.reportOnly != null) {
-                if (typeof object.reportOnly !== "object")
+                if (!$util.isObject(object.reportOnly))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.reportOnly: object expected");
-                message.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.fromObject(object.reportOnly);
+                message.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.fromObject(object.reportOnly, long + 1);
             }
             if (object.ignoreOnly != null) {
-                if (typeof object.ignoreOnly !== "object")
+                if (!$util.isObject(object.ignoreOnly))
                     throw TypeError(".proteus.QualifiedNewOtrMessage.ignoreOnly: object expected");
-                message.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.fromObject(object.ignoreOnly);
+                message.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.fromObject(object.ignoreOnly, long + 1);
             }
             return message;
         };
@@ -2294,9 +2484,13 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        QualifiedNewOtrMessage.toObject = function toObject(message, options) {
+        QualifiedNewOtrMessage.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.arrays || options.defaults)
                 object.recipients = [];
@@ -2313,38 +2507,38 @@ $root.proteus = (function() {
                 object.nativePriority = options.enums === String ? "LOW_PRIORITY" : 1;
                 object.transient = false;
             }
-            if (message.sender != null && message.hasOwnProperty("sender"))
-                object.sender = $root.proteus.ClientId.toObject(message.sender, options);
+            if (message.sender != null && Object.hasOwnProperty.call(message, "sender"))
+                object.sender = $root.proteus.ClientId.toObject(message.sender, options, q + 1);
             if (message.recipients && message.recipients.length) {
                 object.recipients = [];
                 for (var j = 0; j < message.recipients.length; ++j)
-                    object.recipients[j] = $root.proteus.QualifiedUserEntry.toObject(message.recipients[j], options);
+                    object.recipients[j] = $root.proteus.QualifiedUserEntry.toObject(message.recipients[j], options, q + 1);
             }
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 object.nativePush = message.nativePush;
-            if (message.blob != null && message.hasOwnProperty("blob"))
+            if (message.blob != null && Object.hasOwnProperty.call(message, "blob"))
                 object.blob = options.bytes === String ? $util.base64.encode(message.blob, 0, message.blob.length) : options.bytes === Array ? Array.prototype.slice.call(message.blob) : message.blob;
-            if (message.nativePriority != null && message.hasOwnProperty("nativePriority"))
+            if (message.nativePriority != null && Object.hasOwnProperty.call(message, "nativePriority"))
                 object.nativePriority = options.enums === String ? $root.proteus.Priority[message.nativePriority] === undefined ? message.nativePriority : $root.proteus.Priority[message.nativePriority] : message.nativePriority;
-            if (message.transient != null && message.hasOwnProperty("transient"))
+            if (message.transient != null && Object.hasOwnProperty.call(message, "transient"))
                 object.transient = message.transient;
-            if (message.reportAll != null && message.hasOwnProperty("reportAll")) {
-                object.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.toObject(message.reportAll, options);
+            if (message.reportAll != null && Object.hasOwnProperty.call(message, "reportAll")) {
+                object.reportAll = $root.proteus.ClientMismatchStrategy.ReportAll.toObject(message.reportAll, options, q + 1);
                 if (options.oneofs)
                     object.clientMismatchStrategy = "reportAll";
             }
-            if (message.ignoreAll != null && message.hasOwnProperty("ignoreAll")) {
-                object.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.toObject(message.ignoreAll, options);
+            if (message.ignoreAll != null && Object.hasOwnProperty.call(message, "ignoreAll")) {
+                object.ignoreAll = $root.proteus.ClientMismatchStrategy.IgnoreAll.toObject(message.ignoreAll, options, q + 1);
                 if (options.oneofs)
                     object.clientMismatchStrategy = "ignoreAll";
             }
-            if (message.reportOnly != null && message.hasOwnProperty("reportOnly")) {
-                object.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.toObject(message.reportOnly, options);
+            if (message.reportOnly != null && Object.hasOwnProperty.call(message, "reportOnly")) {
+                object.reportOnly = $root.proteus.ClientMismatchStrategy.ReportOnly.toObject(message.reportOnly, options, q + 1);
                 if (options.oneofs)
                     object.clientMismatchStrategy = "reportOnly";
             }
-            if (message.ignoreOnly != null && message.hasOwnProperty("ignoreOnly")) {
-                object.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.toObject(message.ignoreOnly, options);
+            if (message.ignoreOnly != null && Object.hasOwnProperty.call(message, "ignoreOnly")) {
+                object.ignoreOnly = $root.proteus.ClientMismatchStrategy.IgnoreOnly.toObject(message.ignoreOnly, options, q + 1);
                 if (options.oneofs)
                     object.clientMismatchStrategy = "ignoreOnly";
             }
@@ -2399,7 +2593,7 @@ $root.proteus = (function() {
         function ClientMismatchStrategy(properties) {
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -2424,9 +2618,13 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        ClientMismatchStrategy.encode = function encode(message, writer) {
+        ClientMismatchStrategy.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             return writer;
         };
 
@@ -2454,15 +2652,21 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        ClientMismatchStrategy.decode = function decode(reader, length) {
+        ClientMismatchStrategy.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientMismatchStrategy();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
@@ -2493,9 +2697,13 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        ClientMismatchStrategy.verify = function verify(message) {
+        ClientMismatchStrategy.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             return null;
         };
 
@@ -2507,7 +2715,7 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.ClientMismatchStrategy} ClientMismatchStrategy
          */
-        ClientMismatchStrategy.fromObject = function fromObject(object) {
+        ClientMismatchStrategy.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.ClientMismatchStrategy)
                 return object;
             return new $root.proteus.ClientMismatchStrategy();
@@ -2571,7 +2779,7 @@ $root.proteus = (function() {
             function ReportAll(properties) {
                 if (properties)
                     for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                        if (properties[keys[i]] != null)
+                        if (properties[keys[i]] != null && keys[i] !== "__proto__")
                             this[keys[i]] = properties[keys[i]];
             }
 
@@ -2596,9 +2804,13 @@ $root.proteus = (function() {
              * @param {$protobuf.Writer} [writer] Writer to encode to
              * @returns {$protobuf.Writer} Writer
              */
-            ReportAll.encode = function encode(message, writer) {
+            ReportAll.encode = function encode(message, writer, q) {
                 if (!writer)
                     writer = $Writer.create();
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 return writer;
             };
 
@@ -2626,15 +2838,21 @@ $root.proteus = (function() {
              * @throws {Error} If the payload is not a reader or valid buffer
              * @throws {$protobuf.util.ProtocolError} If required fields are missing
              */
-            ReportAll.decode = function decode(reader, length) {
+            ReportAll.decode = function decode(reader, length, error, long) {
                 if (!(reader instanceof $Reader))
                     reader = $Reader.create(reader);
+                if (long === undefined)
+                    long = 0;
+                if (long > $Reader.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientMismatchStrategy.ReportAll();
                 while (reader.pos < end) {
                     var tag = reader.uint32();
+                    if (tag === error)
+                        break;
                     switch (tag >>> 3) {
                     default:
-                        reader.skipType(tag & 7);
+                        reader.skipType(tag & 7, long);
                         break;
                     }
                 }
@@ -2665,9 +2883,13 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} message Plain object to verify
              * @returns {string|null} `null` if valid, otherwise the reason why it is not
              */
-            ReportAll.verify = function verify(message) {
+            ReportAll.verify = function verify(message, long) {
                 if (typeof message !== "object" || message === null)
                     return "object expected";
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    return "maximum nesting depth exceeded";
                 return null;
             };
 
@@ -2679,7 +2901,7 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} object Plain object
              * @returns {proteus.ClientMismatchStrategy.ReportAll} ReportAll
              */
-            ReportAll.fromObject = function fromObject(object) {
+            ReportAll.fromObject = function fromObject(object, long) {
                 if (object instanceof $root.proteus.ClientMismatchStrategy.ReportAll)
                     return object;
                 return new $root.proteus.ClientMismatchStrategy.ReportAll();
@@ -2746,7 +2968,7 @@ $root.proteus = (function() {
             function IgnoreAll(properties) {
                 if (properties)
                     for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                        if (properties[keys[i]] != null)
+                        if (properties[keys[i]] != null && keys[i] !== "__proto__")
                             this[keys[i]] = properties[keys[i]];
             }
 
@@ -2771,9 +2993,13 @@ $root.proteus = (function() {
              * @param {$protobuf.Writer} [writer] Writer to encode to
              * @returns {$protobuf.Writer} Writer
              */
-            IgnoreAll.encode = function encode(message, writer) {
+            IgnoreAll.encode = function encode(message, writer, q) {
                 if (!writer)
                     writer = $Writer.create();
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 return writer;
             };
 
@@ -2801,15 +3027,21 @@ $root.proteus = (function() {
              * @throws {Error} If the payload is not a reader or valid buffer
              * @throws {$protobuf.util.ProtocolError} If required fields are missing
              */
-            IgnoreAll.decode = function decode(reader, length) {
+            IgnoreAll.decode = function decode(reader, length, error, long) {
                 if (!(reader instanceof $Reader))
                     reader = $Reader.create(reader);
+                if (long === undefined)
+                    long = 0;
+                if (long > $Reader.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientMismatchStrategy.IgnoreAll();
                 while (reader.pos < end) {
                     var tag = reader.uint32();
+                    if (tag === error)
+                        break;
                     switch (tag >>> 3) {
                     default:
-                        reader.skipType(tag & 7);
+                        reader.skipType(tag & 7, long);
                         break;
                     }
                 }
@@ -2840,9 +3072,13 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} message Plain object to verify
              * @returns {string|null} `null` if valid, otherwise the reason why it is not
              */
-            IgnoreAll.verify = function verify(message) {
+            IgnoreAll.verify = function verify(message, long) {
                 if (typeof message !== "object" || message === null)
                     return "object expected";
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    return "maximum nesting depth exceeded";
                 return null;
             };
 
@@ -2854,7 +3090,7 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} object Plain object
              * @returns {proteus.ClientMismatchStrategy.IgnoreAll} IgnoreAll
              */
-            IgnoreAll.fromObject = function fromObject(object) {
+            IgnoreAll.fromObject = function fromObject(object, long) {
                 if (object instanceof $root.proteus.ClientMismatchStrategy.IgnoreAll)
                     return object;
                 return new $root.proteus.ClientMismatchStrategy.IgnoreAll();
@@ -2923,7 +3159,7 @@ $root.proteus = (function() {
                 this.userIds = [];
                 if (properties)
                     for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                        if (properties[keys[i]] != null)
+                        if (properties[keys[i]] != null && keys[i] !== "__proto__")
                             this[keys[i]] = properties[keys[i]];
             }
 
@@ -2956,12 +3192,16 @@ $root.proteus = (function() {
              * @param {$protobuf.Writer} [writer] Writer to encode to
              * @returns {$protobuf.Writer} Writer
              */
-            ReportOnly.encode = function encode(message, writer) {
+            ReportOnly.encode = function encode(message, writer, q) {
                 if (!writer)
                     writer = $Writer.create();
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 if (message.userIds != null && message.userIds.length)
                     for (var i = 0; i < message.userIds.length; ++i)
-                        $root.proteus.QualifiedUserId.encode(message.userIds[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                        $root.proteus.QualifiedUserId.encode(message.userIds[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
                 return writer;
             };
 
@@ -2989,21 +3229,27 @@ $root.proteus = (function() {
              * @throws {Error} If the payload is not a reader or valid buffer
              * @throws {$protobuf.util.ProtocolError} If required fields are missing
              */
-            ReportOnly.decode = function decode(reader, length) {
+            ReportOnly.decode = function decode(reader, length, error, long) {
                 if (!(reader instanceof $Reader))
                     reader = $Reader.create(reader);
+                if (long === undefined)
+                    long = 0;
+                if (long > $Reader.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientMismatchStrategy.ReportOnly();
                 while (reader.pos < end) {
                     var tag = reader.uint32();
+                    if (tag === error)
+                        break;
                     switch (tag >>> 3) {
                     case 1: {
                             if (!(message.userIds && message.userIds.length))
                                 message.userIds = [];
-                            message.userIds.push($root.proteus.QualifiedUserId.decode(reader, reader.uint32()));
+                            message.userIds.push($root.proteus.QualifiedUserId.decode(reader, reader.uint32(), undefined, long + 1));
                             break;
                         }
                     default:
-                        reader.skipType(tag & 7);
+                        reader.skipType(tag & 7, long);
                         break;
                     }
                 }
@@ -3034,14 +3280,18 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} message Plain object to verify
              * @returns {string|null} `null` if valid, otherwise the reason why it is not
              */
-            ReportOnly.verify = function verify(message) {
+            ReportOnly.verify = function verify(message, long) {
                 if (typeof message !== "object" || message === null)
                     return "object expected";
-                if (message.userIds != null && message.hasOwnProperty("userIds")) {
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    return "maximum nesting depth exceeded";
+                if (message.userIds != null && Object.hasOwnProperty.call(message, "userIds")) {
                     if (!Array.isArray(message.userIds))
                         return "userIds: array expected";
                     for (var i = 0; i < message.userIds.length; ++i) {
-                        var error = $root.proteus.QualifiedUserId.verify(message.userIds[i]);
+                        var error = $root.proteus.QualifiedUserId.verify(message.userIds[i], long + 1);
                         if (error)
                             return "userIds." + error;
                     }
@@ -3057,18 +3307,24 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} object Plain object
              * @returns {proteus.ClientMismatchStrategy.ReportOnly} ReportOnly
              */
-            ReportOnly.fromObject = function fromObject(object) {
+            ReportOnly.fromObject = function fromObject(object, long) {
                 if (object instanceof $root.proteus.ClientMismatchStrategy.ReportOnly)
                     return object;
+                if (!$util.isObject(object))
+                    throw TypeError(".proteus.ClientMismatchStrategy.ReportOnly: object expected");
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var message = new $root.proteus.ClientMismatchStrategy.ReportOnly();
                 if (object.userIds) {
                     if (!Array.isArray(object.userIds))
                         throw TypeError(".proteus.ClientMismatchStrategy.ReportOnly.userIds: array expected");
                     message.userIds = [];
                     for (var i = 0; i < object.userIds.length; ++i) {
-                        if (typeof object.userIds[i] !== "object")
+                        if (!$util.isObject(object.userIds[i]))
                             throw TypeError(".proteus.ClientMismatchStrategy.ReportOnly.userIds: object expected");
-                        message.userIds[i] = $root.proteus.QualifiedUserId.fromObject(object.userIds[i]);
+                        message.userIds[i] = $root.proteus.QualifiedUserId.fromObject(object.userIds[i], long + 1);
                     }
                 }
                 return message;
@@ -3083,16 +3339,20 @@ $root.proteus = (function() {
              * @param {$protobuf.IConversionOptions} [options] Conversion options
              * @returns {Object.<string,*>} Plain object
              */
-            ReportOnly.toObject = function toObject(message, options) {
+            ReportOnly.toObject = function toObject(message, options, q) {
                 if (!options)
                     options = {};
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 var object = {};
                 if (options.arrays || options.defaults)
                     object.userIds = [];
                 if (message.userIds && message.userIds.length) {
                     object.userIds = [];
                     for (var j = 0; j < message.userIds.length; ++j)
-                        object.userIds[j] = $root.proteus.QualifiedUserId.toObject(message.userIds[j], options);
+                        object.userIds[j] = $root.proteus.QualifiedUserId.toObject(message.userIds[j], options, q + 1);
                 }
                 return object;
             };
@@ -3147,7 +3407,7 @@ $root.proteus = (function() {
                 this.userIds = [];
                 if (properties)
                     for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                        if (properties[keys[i]] != null)
+                        if (properties[keys[i]] != null && keys[i] !== "__proto__")
                             this[keys[i]] = properties[keys[i]];
             }
 
@@ -3180,12 +3440,16 @@ $root.proteus = (function() {
              * @param {$protobuf.Writer} [writer] Writer to encode to
              * @returns {$protobuf.Writer} Writer
              */
-            IgnoreOnly.encode = function encode(message, writer) {
+            IgnoreOnly.encode = function encode(message, writer, q) {
                 if (!writer)
                     writer = $Writer.create();
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 if (message.userIds != null && message.userIds.length)
                     for (var i = 0; i < message.userIds.length; ++i)
-                        $root.proteus.QualifiedUserId.encode(message.userIds[i], writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                        $root.proteus.QualifiedUserId.encode(message.userIds[i], writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
                 return writer;
             };
 
@@ -3213,21 +3477,27 @@ $root.proteus = (function() {
              * @throws {Error} If the payload is not a reader or valid buffer
              * @throws {$protobuf.util.ProtocolError} If required fields are missing
              */
-            IgnoreOnly.decode = function decode(reader, length) {
+            IgnoreOnly.decode = function decode(reader, length, error, long) {
                 if (!(reader instanceof $Reader))
                     reader = $Reader.create(reader);
+                if (long === undefined)
+                    long = 0;
+                if (long > $Reader.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.ClientMismatchStrategy.IgnoreOnly();
                 while (reader.pos < end) {
                     var tag = reader.uint32();
+                    if (tag === error)
+                        break;
                     switch (tag >>> 3) {
                     case 1: {
                             if (!(message.userIds && message.userIds.length))
                                 message.userIds = [];
-                            message.userIds.push($root.proteus.QualifiedUserId.decode(reader, reader.uint32()));
+                            message.userIds.push($root.proteus.QualifiedUserId.decode(reader, reader.uint32(), undefined, long + 1));
                             break;
                         }
                     default:
-                        reader.skipType(tag & 7);
+                        reader.skipType(tag & 7, long);
                         break;
                     }
                 }
@@ -3258,14 +3528,18 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} message Plain object to verify
              * @returns {string|null} `null` if valid, otherwise the reason why it is not
              */
-            IgnoreOnly.verify = function verify(message) {
+            IgnoreOnly.verify = function verify(message, long) {
                 if (typeof message !== "object" || message === null)
                     return "object expected";
-                if (message.userIds != null && message.hasOwnProperty("userIds")) {
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    return "maximum nesting depth exceeded";
+                if (message.userIds != null && Object.hasOwnProperty.call(message, "userIds")) {
                     if (!Array.isArray(message.userIds))
                         return "userIds: array expected";
                     for (var i = 0; i < message.userIds.length; ++i) {
-                        var error = $root.proteus.QualifiedUserId.verify(message.userIds[i]);
+                        var error = $root.proteus.QualifiedUserId.verify(message.userIds[i], long + 1);
                         if (error)
                             return "userIds." + error;
                     }
@@ -3281,18 +3555,24 @@ $root.proteus = (function() {
              * @param {Object.<string,*>} object Plain object
              * @returns {proteus.ClientMismatchStrategy.IgnoreOnly} IgnoreOnly
              */
-            IgnoreOnly.fromObject = function fromObject(object) {
+            IgnoreOnly.fromObject = function fromObject(object, long) {
                 if (object instanceof $root.proteus.ClientMismatchStrategy.IgnoreOnly)
                     return object;
+                if (!$util.isObject(object))
+                    throw TypeError(".proteus.ClientMismatchStrategy.IgnoreOnly: object expected");
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
                 var message = new $root.proteus.ClientMismatchStrategy.IgnoreOnly();
                 if (object.userIds) {
                     if (!Array.isArray(object.userIds))
                         throw TypeError(".proteus.ClientMismatchStrategy.IgnoreOnly.userIds: array expected");
                     message.userIds = [];
                     for (var i = 0; i < object.userIds.length; ++i) {
-                        if (typeof object.userIds[i] !== "object")
+                        if (!$util.isObject(object.userIds[i]))
                             throw TypeError(".proteus.ClientMismatchStrategy.IgnoreOnly.userIds: object expected");
-                        message.userIds[i] = $root.proteus.QualifiedUserId.fromObject(object.userIds[i]);
+                        message.userIds[i] = $root.proteus.QualifiedUserId.fromObject(object.userIds[i], long + 1);
                     }
                 }
                 return message;
@@ -3307,16 +3587,20 @@ $root.proteus = (function() {
              * @param {$protobuf.IConversionOptions} [options] Conversion options
              * @returns {Object.<string,*>} Plain object
              */
-            IgnoreOnly.toObject = function toObject(message, options) {
+            IgnoreOnly.toObject = function toObject(message, options, q) {
                 if (!options)
                     options = {};
+                if (q === undefined)
+                    q = 0;
+                if (q > $util.recursionLimit)
+                    throw Error("max depth exceeded");
                 var object = {};
                 if (options.arrays || options.defaults)
                     object.userIds = [];
                 if (message.userIds && message.userIds.length) {
                     object.userIds = [];
                     for (var j = 0; j < message.userIds.length; ++j)
-                        object.userIds[j] = $root.proteus.QualifiedUserId.toObject(message.userIds[j], options);
+                        object.userIds[j] = $root.proteus.QualifiedUserId.toObject(message.userIds[j], options, q + 1);
                 }
                 return object;
             };
@@ -3377,7 +3661,7 @@ $root.proteus = (function() {
             this.recipients = [];
             if (properties)
                 for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
-                    if (properties[keys[i]] != null)
+                    if (properties[keys[i]] != null && keys[i] !== "__proto__")
                         this[keys[i]] = properties[keys[i]];
         }
 
@@ -3434,13 +3718,17 @@ $root.proteus = (function() {
          * @param {$protobuf.Writer} [writer] Writer to encode to
          * @returns {$protobuf.Writer} Writer
          */
-        OtrAssetMeta.encode = function encode(message, writer) {
+        OtrAssetMeta.encode = function encode(message, writer, q) {
             if (!writer)
                 writer = $Writer.create();
-            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
+            $root.proteus.ClientId.encode(message.sender, writer.uint32(/* id 1, wireType 2 =*/10).fork(), q + 1).ldelim();
             if (message.recipients != null && message.recipients.length)
                 for (var i = 0; i < message.recipients.length; ++i)
-                    $root.proteus.UserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                    $root.proteus.UserEntry.encode(message.recipients[i], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim();
             if (message.isInline != null && Object.hasOwnProperty.call(message, "isInline"))
                 writer.uint32(/* id 3, wireType 0 =*/24).bool(message.isInline);
             if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
@@ -3472,21 +3760,27 @@ $root.proteus = (function() {
          * @throws {Error} If the payload is not a reader or valid buffer
          * @throws {$protobuf.util.ProtocolError} If required fields are missing
          */
-        OtrAssetMeta.decode = function decode(reader, length) {
+        OtrAssetMeta.decode = function decode(reader, length, error, long) {
             if (!(reader instanceof $Reader))
                 reader = $Reader.create(reader);
+            if (long === undefined)
+                long = 0;
+            if (long > $Reader.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var end = length === undefined ? reader.len : reader.pos + length, message = new $root.proteus.OtrAssetMeta();
             while (reader.pos < end) {
                 var tag = reader.uint32();
+                if (tag === error)
+                    break;
                 switch (tag >>> 3) {
                 case 1: {
-                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32());
+                        message.sender = $root.proteus.ClientId.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
                 case 2: {
                         if (!(message.recipients && message.recipients.length))
                             message.recipients = [];
-                        message.recipients.push($root.proteus.UserEntry.decode(reader, reader.uint32()));
+                        message.recipients.push($root.proteus.UserEntry.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
                 case 3: {
@@ -3498,11 +3792,11 @@ $root.proteus = (function() {
                         break;
                     }
                 default:
-                    reader.skipType(tag & 7);
+                    reader.skipType(tag & 7, long);
                     break;
                 }
             }
-            if (!message.hasOwnProperty("sender"))
+            if (!Object.hasOwnProperty.call(message, "sender"))
                 throw $util.ProtocolError("missing required 'sender'", { instance: message });
             return message;
         };
@@ -3531,27 +3825,31 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} message Plain object to verify
          * @returns {string|null} `null` if valid, otherwise the reason why it is not
          */
-        OtrAssetMeta.verify = function verify(message) {
+        OtrAssetMeta.verify = function verify(message, long) {
             if (typeof message !== "object" || message === null)
                 return "object expected";
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                return "maximum nesting depth exceeded";
             {
-                var error = $root.proteus.ClientId.verify(message.sender);
+                var error = $root.proteus.ClientId.verify(message.sender, long + 1);
                 if (error)
                     return "sender." + error;
             }
-            if (message.recipients != null && message.hasOwnProperty("recipients")) {
+            if (message.recipients != null && Object.hasOwnProperty.call(message, "recipients")) {
                 if (!Array.isArray(message.recipients))
                     return "recipients: array expected";
                 for (var i = 0; i < message.recipients.length; ++i) {
-                    var error = $root.proteus.UserEntry.verify(message.recipients[i]);
+                    var error = $root.proteus.UserEntry.verify(message.recipients[i], long + 1);
                     if (error)
                         return "recipients." + error;
                 }
             }
-            if (message.isInline != null && message.hasOwnProperty("isInline"))
+            if (message.isInline != null && Object.hasOwnProperty.call(message, "isInline"))
                 if (typeof message.isInline !== "boolean")
                     return "isInline: boolean expected";
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 if (typeof message.nativePush !== "boolean")
                     return "nativePush: boolean expected";
             return null;
@@ -3565,23 +3863,29 @@ $root.proteus = (function() {
          * @param {Object.<string,*>} object Plain object
          * @returns {proteus.OtrAssetMeta} OtrAssetMeta
          */
-        OtrAssetMeta.fromObject = function fromObject(object) {
+        OtrAssetMeta.fromObject = function fromObject(object, long) {
             if (object instanceof $root.proteus.OtrAssetMeta)
                 return object;
+            if (!$util.isObject(object))
+                throw TypeError(".proteus.OtrAssetMeta: object expected");
+            if (long === undefined)
+                long = 0;
+            if (long > $util.recursionLimit)
+                throw Error("maximum nesting depth exceeded");
             var message = new $root.proteus.OtrAssetMeta();
             if (object.sender != null) {
-                if (typeof object.sender !== "object")
+                if (!$util.isObject(object.sender))
                     throw TypeError(".proteus.OtrAssetMeta.sender: object expected");
-                message.sender = $root.proteus.ClientId.fromObject(object.sender);
+                message.sender = $root.proteus.ClientId.fromObject(object.sender, long + 1);
             }
             if (object.recipients) {
                 if (!Array.isArray(object.recipients))
                     throw TypeError(".proteus.OtrAssetMeta.recipients: array expected");
                 message.recipients = [];
                 for (var i = 0; i < object.recipients.length; ++i) {
-                    if (typeof object.recipients[i] !== "object")
+                    if (!$util.isObject(object.recipients[i]))
                         throw TypeError(".proteus.OtrAssetMeta.recipients: object expected");
-                    message.recipients[i] = $root.proteus.UserEntry.fromObject(object.recipients[i]);
+                    message.recipients[i] = $root.proteus.UserEntry.fromObject(object.recipients[i], long + 1);
                 }
             }
             if (object.isInline != null)
@@ -3600,9 +3904,13 @@ $root.proteus = (function() {
          * @param {$protobuf.IConversionOptions} [options] Conversion options
          * @returns {Object.<string,*>} Plain object
          */
-        OtrAssetMeta.toObject = function toObject(message, options) {
+        OtrAssetMeta.toObject = function toObject(message, options, q) {
             if (!options)
                 options = {};
+            if (q === undefined)
+                q = 0;
+            if (q > $util.recursionLimit)
+                throw Error("max depth exceeded");
             var object = {};
             if (options.arrays || options.defaults)
                 object.recipients = [];
@@ -3611,16 +3919,16 @@ $root.proteus = (function() {
                 object.isInline = false;
                 object.nativePush = true;
             }
-            if (message.sender != null && message.hasOwnProperty("sender"))
-                object.sender = $root.proteus.ClientId.toObject(message.sender, options);
+            if (message.sender != null && Object.hasOwnProperty.call(message, "sender"))
+                object.sender = $root.proteus.ClientId.toObject(message.sender, options, q + 1);
             if (message.recipients && message.recipients.length) {
                 object.recipients = [];
                 for (var j = 0; j < message.recipients.length; ++j)
-                    object.recipients[j] = $root.proteus.UserEntry.toObject(message.recipients[j], options);
+                    object.recipients[j] = $root.proteus.UserEntry.toObject(message.recipients[j], options, q + 1);
             }
-            if (message.isInline != null && message.hasOwnProperty("isInline"))
+            if (message.isInline != null && Object.hasOwnProperty.call(message, "isInline"))
                 object.isInline = message.isInline;
-            if (message.nativePush != null && message.hasOwnProperty("nativePush"))
+            if (message.nativePush != null && Object.hasOwnProperty.call(message, "nativePush"))
                 object.nativePush = message.nativePush;
             return object;
         };