@replit/protocol 0.3.0 → 0.3.1

package/main/index.js

@@ -55131,6 +55131,2785 @@
                     return GovalReplIdentity;
                 })();
     
+                api.lore = (function() {
+    
+                    /**
+                     * Namespace lore.
+                     * @memberof replit.goval.api
+                     * @namespace
+                     */
+                    var lore = {};
+    
+                    lore.LoreCommand = (function() {
+    
+                        /**
+                         * Properties of a LoreCommand.
+                         * @memberof replit.goval.api.lore
+                         * @interface ILoreCommand
+                         * @property {replit.goval.api.lore.ClusterTransfer|replit.goval.api.lore.IClusterTransfer|null} [clusterTransfer] LoreCommand clusterTransfer
+                         * @property {replit.goval.api.lore.SoftTakedown|replit.goval.api.lore.ISoftTakedown|null} [softTakedown] LoreCommand softTakedown
+                         * @property {replit.goval.api.lore.Takedown|replit.goval.api.lore.ITakedown|null} [takedown] LoreCommand takedown
+                         * @property {replit.goval.api.lore.GovalCommand|replit.goval.api.lore.IGovalCommand|null} [govalCommand] LoreCommand govalCommand
+                         * @property {replit.goval.api.lore.MultiGovalCommand|replit.goval.api.lore.IMultiGovalCommand|null} [multiGovalCommand] LoreCommand multiGovalCommand
+                         * @property {replit.goval.api.lore.Restore|replit.goval.api.lore.IRestore|null} [restore] LoreCommand restore
+                         */
+    
+                        /**
+                         * Constructs a new LoreCommand.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a LoreCommand.
+                         * @constructor
+                         * @param {replit.goval.api.lore.ILoreCommand=} [properties] Properties to set
+                         */
+                        function LoreCommand(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * LoreCommand clusterTransfer.
+                         * @member {replit.goval.api.lore.ClusterTransfer|null|undefined} clusterTransfer
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.clusterTransfer = null;
+    
+                        /**
+                         * LoreCommand softTakedown.
+                         * @member {replit.goval.api.lore.SoftTakedown|null|undefined} softTakedown
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.softTakedown = null;
+    
+                        /**
+                         * LoreCommand takedown.
+                         * @member {replit.goval.api.lore.Takedown|null|undefined} takedown
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.takedown = null;
+    
+                        /**
+                         * LoreCommand govalCommand.
+                         * @member {replit.goval.api.lore.GovalCommand|null|undefined} govalCommand
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.govalCommand = null;
+    
+                        /**
+                         * LoreCommand multiGovalCommand.
+                         * @member {replit.goval.api.lore.MultiGovalCommand|null|undefined} multiGovalCommand
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.multiGovalCommand = null;
+    
+                        /**
+                         * LoreCommand restore.
+                         * @member {replit.goval.api.lore.Restore|null|undefined} restore
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        LoreCommand.prototype.restore = null;
+    
+                        // OneOf field names bound to virtual getters and setters
+                        var $oneOfFields;
+    
+                        /**
+                         * LoreCommand command.
+                         * @member {"clusterTransfer"|"softTakedown"|"takedown"|"govalCommand"|"multiGovalCommand"|"restore"|undefined} command
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         */
+                        Object.defineProperty(LoreCommand.prototype, "command", {
+                            get: $util.oneOfGetter($oneOfFields = ["clusterTransfer", "softTakedown", "takedown", "govalCommand", "multiGovalCommand", "restore"]),
+                            set: $util.oneOfSetter($oneOfFields)
+                        });
+    
+                        /**
+                         * Creates a new LoreCommand instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {replit.goval.api.lore.ILoreCommand=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.LoreCommand} LoreCommand instance
+                         */
+                        LoreCommand.create = function create(properties) {
+                            return LoreCommand.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified LoreCommand message. Does not implicitly {@link replit.goval.api.lore.LoreCommand.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {replit.goval.api.lore.LoreCommand} message LoreCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        LoreCommand.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.clusterTransfer != null && Object.hasOwnProperty.call(message, "clusterTransfer"))
+                                $root.replit.goval.api.lore.ClusterTransfer.encode(message.clusterTransfer, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.softTakedown != null && Object.hasOwnProperty.call(message, "softTakedown"))
+                                $root.replit.goval.api.lore.SoftTakedown.encode(message.softTakedown, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            if (message.govalCommand != null && Object.hasOwnProperty.call(message, "govalCommand"))
+                                $root.replit.goval.api.lore.GovalCommand.encode(message.govalCommand, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+                            if (message.restore != null && Object.hasOwnProperty.call(message, "restore"))
+                                $root.replit.goval.api.lore.Restore.encode(message.restore, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
+                            if (message.multiGovalCommand != null && Object.hasOwnProperty.call(message, "multiGovalCommand"))
+                                $root.replit.goval.api.lore.MultiGovalCommand.encode(message.multiGovalCommand, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
+                            if (message.takedown != null && Object.hasOwnProperty.call(message, "takedown"))
+                                $root.replit.goval.api.lore.Takedown.encode(message.takedown, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified LoreCommand message, length delimited. Does not implicitly {@link replit.goval.api.lore.LoreCommand.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {replit.goval.api.lore.LoreCommand} message LoreCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        LoreCommand.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a LoreCommand message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.LoreCommand} LoreCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        LoreCommand.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.LoreCommand();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.clusterTransfer = $root.replit.goval.api.lore.ClusterTransfer.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    message.softTakedown = $root.replit.goval.api.lore.SoftTakedown.decode(reader, reader.uint32());
+                                    break;
+                                case 6:
+                                    message.takedown = $root.replit.goval.api.lore.Takedown.decode(reader, reader.uint32());
+                                    break;
+                                case 3:
+                                    message.govalCommand = $root.replit.goval.api.lore.GovalCommand.decode(reader, reader.uint32());
+                                    break;
+                                case 5:
+                                    message.multiGovalCommand = $root.replit.goval.api.lore.MultiGovalCommand.decode(reader, reader.uint32());
+                                    break;
+                                case 4:
+                                    message.restore = $root.replit.goval.api.lore.Restore.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a LoreCommand message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.LoreCommand} LoreCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        LoreCommand.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a LoreCommand message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        LoreCommand.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            var properties = {};
+                            if (message.clusterTransfer != null && message.hasOwnProperty("clusterTransfer")) {
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.ClusterTransfer.verify(message.clusterTransfer);
+                                    if (error)
+                                        return "clusterTransfer." + error;
+                                }
+                            }
+                            if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.SoftTakedown.verify(message.softTakedown);
+                                    if (error)
+                                        return "softTakedown." + error;
+                                }
+                            }
+                            if (message.takedown != null && message.hasOwnProperty("takedown")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.Takedown.verify(message.takedown);
+                                    if (error)
+                                        return "takedown." + error;
+                                }
+                            }
+                            if (message.govalCommand != null && message.hasOwnProperty("govalCommand")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.GovalCommand.verify(message.govalCommand);
+                                    if (error)
+                                        return "govalCommand." + error;
+                                }
+                            }
+                            if (message.multiGovalCommand != null && message.hasOwnProperty("multiGovalCommand")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.MultiGovalCommand.verify(message.multiGovalCommand);
+                                    if (error)
+                                        return "multiGovalCommand." + error;
+                                }
+                            }
+                            if (message.restore != null && message.hasOwnProperty("restore")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.Restore.verify(message.restore);
+                                    if (error)
+                                        return "restore." + error;
+                                }
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a LoreCommand message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.LoreCommand} LoreCommand
+                         */
+                        LoreCommand.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.LoreCommand)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.LoreCommand();
+                            if (object.clusterTransfer != null) {
+                                if (typeof object.clusterTransfer !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.clusterTransfer: object expected");
+                                message.clusterTransfer = $root.replit.goval.api.lore.ClusterTransfer.fromObject(object.clusterTransfer);
+                            }
+                            if (object.softTakedown != null) {
+                                if (typeof object.softTakedown !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.softTakedown: object expected");
+                                message.softTakedown = $root.replit.goval.api.lore.SoftTakedown.fromObject(object.softTakedown);
+                            }
+                            if (object.takedown != null) {
+                                if (typeof object.takedown !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.takedown: object expected");
+                                message.takedown = $root.replit.goval.api.lore.Takedown.fromObject(object.takedown);
+                            }
+                            if (object.govalCommand != null) {
+                                if (typeof object.govalCommand !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.govalCommand: object expected");
+                                message.govalCommand = $root.replit.goval.api.lore.GovalCommand.fromObject(object.govalCommand);
+                            }
+                            if (object.multiGovalCommand != null) {
+                                if (typeof object.multiGovalCommand !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.multiGovalCommand: object expected");
+                                message.multiGovalCommand = $root.replit.goval.api.lore.MultiGovalCommand.fromObject(object.multiGovalCommand);
+                            }
+                            if (object.restore != null) {
+                                if (typeof object.restore !== "object")
+                                    throw TypeError(".replit.goval.api.lore.LoreCommand.restore: object expected");
+                                message.restore = $root.replit.goval.api.lore.Restore.fromObject(object.restore);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a LoreCommand message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @static
+                         * @param {replit.goval.api.lore.LoreCommand} message LoreCommand
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        LoreCommand.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (message.clusterTransfer != null && message.hasOwnProperty("clusterTransfer")) {
+                                object.clusterTransfer = $root.replit.goval.api.lore.ClusterTransfer.toObject(message.clusterTransfer, options);
+                                if (options.oneofs)
+                                    object.command = "clusterTransfer";
+                            }
+                            if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
+                                object.softTakedown = $root.replit.goval.api.lore.SoftTakedown.toObject(message.softTakedown, options);
+                                if (options.oneofs)
+                                    object.command = "softTakedown";
+                            }
+                            if (message.govalCommand != null && message.hasOwnProperty("govalCommand")) {
+                                object.govalCommand = $root.replit.goval.api.lore.GovalCommand.toObject(message.govalCommand, options);
+                                if (options.oneofs)
+                                    object.command = "govalCommand";
+                            }
+                            if (message.restore != null && message.hasOwnProperty("restore")) {
+                                object.restore = $root.replit.goval.api.lore.Restore.toObject(message.restore, options);
+                                if (options.oneofs)
+                                    object.command = "restore";
+                            }
+                            if (message.multiGovalCommand != null && message.hasOwnProperty("multiGovalCommand")) {
+                                object.multiGovalCommand = $root.replit.goval.api.lore.MultiGovalCommand.toObject(message.multiGovalCommand, options);
+                                if (options.oneofs)
+                                    object.command = "multiGovalCommand";
+                            }
+                            if (message.takedown != null && message.hasOwnProperty("takedown")) {
+                                object.takedown = $root.replit.goval.api.lore.Takedown.toObject(message.takedown, options);
+                                if (options.oneofs)
+                                    object.command = "takedown";
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this LoreCommand to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.LoreCommand
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        LoreCommand.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return LoreCommand;
+                    })();
+    
+                    lore.ClusterTransfer = (function() {
+    
+                        /**
+                         * Properties of a ClusterTransfer.
+                         * @memberof replit.goval.api.lore
+                         * @interface IClusterTransfer
+                         * @property {string|null} [replId] ClusterTransfer replId
+                         * @property {string|null} [user] ClusterTransfer user
+                         * @property {string|null} [newClusterId] ClusterTransfer newClusterId
+                         * @property {string|null} [newContinentId] ClusterTransfer newContinentId
+                         * @property {string|null} [transferId] ClusterTransfer transferId
+                         */
+    
+                        /**
+                         * Constructs a new ClusterTransfer.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a ClusterTransfer.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IClusterTransfer=} [properties] Properties to set
+                         */
+                        function ClusterTransfer(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * ClusterTransfer replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        ClusterTransfer.prototype.replId = "";
+    
+                        /**
+                         * ClusterTransfer user.
+                         * @member {string} user
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        ClusterTransfer.prototype.user = "";
+    
+                        /**
+                         * ClusterTransfer newClusterId.
+                         * @member {string|null|undefined} newClusterId
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        ClusterTransfer.prototype.newClusterId = null;
+    
+                        /**
+                         * ClusterTransfer newContinentId.
+                         * @member {string|null|undefined} newContinentId
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        ClusterTransfer.prototype.newContinentId = null;
+    
+                        /**
+                         * ClusterTransfer transferId.
+                         * @member {string} transferId
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        ClusterTransfer.prototype.transferId = "";
+    
+                        // OneOf field names bound to virtual getters and setters
+                        var $oneOfFields;
+    
+                        /**
+                         * ClusterTransfer location.
+                         * @member {"newClusterId"|"newContinentId"|undefined} location
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         */
+                        Object.defineProperty(ClusterTransfer.prototype, "location", {
+                            get: $util.oneOfGetter($oneOfFields = ["newClusterId", "newContinentId"]),
+                            set: $util.oneOfSetter($oneOfFields)
+                        });
+    
+                        /**
+                         * Creates a new ClusterTransfer instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {replit.goval.api.lore.IClusterTransfer=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.ClusterTransfer} ClusterTransfer instance
+                         */
+                        ClusterTransfer.create = function create(properties) {
+                            return ClusterTransfer.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified ClusterTransfer message. Does not implicitly {@link replit.goval.api.lore.ClusterTransfer.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {replit.goval.api.lore.ClusterTransfer} message ClusterTransfer message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        ClusterTransfer.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.user != null && Object.hasOwnProperty.call(message, "user"))
+                                writer.uint32(/* id 2, wireType 2 =*/18).string(message.user);
+                            if (message.newClusterId != null && Object.hasOwnProperty.call(message, "newClusterId"))
+                                writer.uint32(/* id 3, wireType 2 =*/26).string(message.newClusterId);
+                            if (message.transferId != null && Object.hasOwnProperty.call(message, "transferId"))
+                                writer.uint32(/* id 4, wireType 2 =*/34).string(message.transferId);
+                            if (message.newContinentId != null && Object.hasOwnProperty.call(message, "newContinentId"))
+                                writer.uint32(/* id 5, wireType 2 =*/42).string(message.newContinentId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified ClusterTransfer message, length delimited. Does not implicitly {@link replit.goval.api.lore.ClusterTransfer.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {replit.goval.api.lore.ClusterTransfer} message ClusterTransfer message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        ClusterTransfer.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a ClusterTransfer message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.ClusterTransfer} ClusterTransfer
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        ClusterTransfer.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.ClusterTransfer();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    message.user = reader.string();
+                                    break;
+                                case 3:
+                                    message.newClusterId = reader.string();
+                                    break;
+                                case 5:
+                                    message.newContinentId = reader.string();
+                                    break;
+                                case 4:
+                                    message.transferId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a ClusterTransfer message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.ClusterTransfer} ClusterTransfer
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        ClusterTransfer.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a ClusterTransfer message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        ClusterTransfer.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            var properties = {};
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.user != null && message.hasOwnProperty("user"))
+                                if (!$util.isString(message.user))
+                                    return "user: string expected";
+                            if (message.newClusterId != null && message.hasOwnProperty("newClusterId")) {
+                                properties.location = 1;
+                                if (!$util.isString(message.newClusterId))
+                                    return "newClusterId: string expected";
+                            }
+                            if (message.newContinentId != null && message.hasOwnProperty("newContinentId")) {
+                                if (properties.location === 1)
+                                    return "location: multiple values";
+                                properties.location = 1;
+                                if (!$util.isString(message.newContinentId))
+                                    return "newContinentId: string expected";
+                            }
+                            if (message.transferId != null && message.hasOwnProperty("transferId"))
+                                if (!$util.isString(message.transferId))
+                                    return "transferId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a ClusterTransfer message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.ClusterTransfer} ClusterTransfer
+                         */
+                        ClusterTransfer.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.ClusterTransfer)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.ClusterTransfer();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.user != null)
+                                message.user = String(object.user);
+                            if (object.newClusterId != null)
+                                message.newClusterId = String(object.newClusterId);
+                            if (object.newContinentId != null)
+                                message.newContinentId = String(object.newContinentId);
+                            if (object.transferId != null)
+                                message.transferId = String(object.transferId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a ClusterTransfer message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @static
+                         * @param {replit.goval.api.lore.ClusterTransfer} message ClusterTransfer
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        ClusterTransfer.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.replId = "";
+                                object.user = "";
+                                object.transferId = "";
+                            }
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.user != null && message.hasOwnProperty("user"))
+                                object.user = message.user;
+                            if (message.newClusterId != null && message.hasOwnProperty("newClusterId")) {
+                                object.newClusterId = message.newClusterId;
+                                if (options.oneofs)
+                                    object.location = "newClusterId";
+                            }
+                            if (message.transferId != null && message.hasOwnProperty("transferId"))
+                                object.transferId = message.transferId;
+                            if (message.newContinentId != null && message.hasOwnProperty("newContinentId")) {
+                                object.newContinentId = message.newContinentId;
+                                if (options.oneofs)
+                                    object.location = "newContinentId";
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this ClusterTransfer to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.ClusterTransfer
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        ClusterTransfer.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return ClusterTransfer;
+                    })();
+    
+                    lore.SoftTakedown = (function() {
+    
+                        /**
+                         * Properties of a SoftTakedown.
+                         * @memberof replit.goval.api.lore
+                         * @interface ISoftTakedown
+                         * @property {string|null} [replId] SoftTakedown replId
+                         * @property {string|null} [softTakedownId] SoftTakedown softTakedownId
+                         */
+    
+                        /**
+                         * Constructs a new SoftTakedown.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a SoftTakedown.
+                         * @constructor
+                         * @param {replit.goval.api.lore.ISoftTakedown=} [properties] Properties to set
+                         */
+                        function SoftTakedown(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * SoftTakedown replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @instance
+                         */
+                        SoftTakedown.prototype.replId = "";
+    
+                        /**
+                         * SoftTakedown softTakedownId.
+                         * @member {string} softTakedownId
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @instance
+                         */
+                        SoftTakedown.prototype.softTakedownId = "";
+    
+                        /**
+                         * Creates a new SoftTakedown instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {replit.goval.api.lore.ISoftTakedown=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.SoftTakedown} SoftTakedown instance
+                         */
+                        SoftTakedown.create = function create(properties) {
+                            return SoftTakedown.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified SoftTakedown message. Does not implicitly {@link replit.goval.api.lore.SoftTakedown.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {replit.goval.api.lore.SoftTakedown} message SoftTakedown message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        SoftTakedown.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.softTakedownId != null && Object.hasOwnProperty.call(message, "softTakedownId"))
+                                writer.uint32(/* id 2, wireType 2 =*/18).string(message.softTakedownId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified SoftTakedown message, length delimited. Does not implicitly {@link replit.goval.api.lore.SoftTakedown.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {replit.goval.api.lore.SoftTakedown} message SoftTakedown message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        SoftTakedown.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a SoftTakedown message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.SoftTakedown} SoftTakedown
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        SoftTakedown.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.SoftTakedown();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    message.softTakedownId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a SoftTakedown message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.SoftTakedown} SoftTakedown
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        SoftTakedown.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a SoftTakedown message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        SoftTakedown.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.softTakedownId != null && message.hasOwnProperty("softTakedownId"))
+                                if (!$util.isString(message.softTakedownId))
+                                    return "softTakedownId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a SoftTakedown message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.SoftTakedown} SoftTakedown
+                         */
+                        SoftTakedown.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.SoftTakedown)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.SoftTakedown();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.softTakedownId != null)
+                                message.softTakedownId = String(object.softTakedownId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a SoftTakedown message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @static
+                         * @param {replit.goval.api.lore.SoftTakedown} message SoftTakedown
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        SoftTakedown.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.replId = "";
+                                object.softTakedownId = "";
+                            }
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.softTakedownId != null && message.hasOwnProperty("softTakedownId"))
+                                object.softTakedownId = message.softTakedownId;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this SoftTakedown to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.SoftTakedown
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        SoftTakedown.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return SoftTakedown;
+                    })();
+    
+                    lore.Takedown = (function() {
+    
+                        /**
+                         * Properties of a Takedown.
+                         * @memberof replit.goval.api.lore
+                         * @interface ITakedown
+                         * @property {string|null} [replId] Takedown replId
+                         */
+    
+                        /**
+                         * Constructs a new Takedown.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a Takedown.
+                         * @constructor
+                         * @param {replit.goval.api.lore.ITakedown=} [properties] Properties to set
+                         */
+                        function Takedown(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * Takedown replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @instance
+                         */
+                        Takedown.prototype.replId = "";
+    
+                        /**
+                         * Creates a new Takedown instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {replit.goval.api.lore.ITakedown=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.Takedown} Takedown instance
+                         */
+                        Takedown.create = function create(properties) {
+                            return Takedown.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified Takedown message. Does not implicitly {@link replit.goval.api.lore.Takedown.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {replit.goval.api.lore.Takedown} message Takedown message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        Takedown.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified Takedown message, length delimited. Does not implicitly {@link replit.goval.api.lore.Takedown.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {replit.goval.api.lore.Takedown} message Takedown message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        Takedown.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a Takedown message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.Takedown} Takedown
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        Takedown.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.Takedown();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a Takedown message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.Takedown} Takedown
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        Takedown.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a Takedown message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        Takedown.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a Takedown message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.Takedown} Takedown
+                         */
+                        Takedown.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.Takedown)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.Takedown();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a Takedown message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @static
+                         * @param {replit.goval.api.lore.Takedown} message Takedown
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        Takedown.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.replId = "";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this Takedown to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.Takedown
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        Takedown.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return Takedown;
+                    })();
+    
+                    lore.GovalCommand = (function() {
+    
+                        /**
+                         * Properties of a GovalCommand.
+                         * @memberof replit.goval.api.lore
+                         * @interface IGovalCommand
+                         * @property {replit.goval.api.repl.Metadata|replit.goval.api.repl.IMetadata|null} [updateMetadata] GovalCommand updateMetadata
+                         * @property {replit.goval.api.lore.PartialUpdateMetadata|replit.goval.api.lore.IPartialUpdateMetadata|null} [partialUpdateMetadata] GovalCommand partialUpdateMetadata
+                         * @property {replit.goval.api.lore.KillRepl|replit.goval.api.lore.IKillRepl|null} [killRepl] GovalCommand killRepl
+                         * @property {replit.goval.api.lore.UpdateSourceRepl|replit.goval.api.lore.IUpdateSourceRepl|null} [updateSourceRepl] GovalCommand updateSourceRepl
+                         * @property {replit.goval.api.lore.UpdateReplFlags|replit.goval.api.lore.IUpdateReplFlags|null} [updateReplFlags] GovalCommand updateReplFlags
+                         * @property {replit.goval.api.lore.SoftTakedown|replit.goval.api.lore.ISoftTakedown|null} [softTakedown] GovalCommand softTakedown
+                         * @property {replit.goval.api.lore.Takedown|replit.goval.api.lore.ITakedown|null} [takedown] GovalCommand takedown
+                         */
+    
+                        /**
+                         * Constructs a new GovalCommand.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a GovalCommand.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IGovalCommand=} [properties] Properties to set
+                         */
+                        function GovalCommand(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * GovalCommand updateMetadata.
+                         * @member {replit.goval.api.repl.Metadata|null|undefined} updateMetadata
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.updateMetadata = null;
+    
+                        /**
+                         * GovalCommand partialUpdateMetadata.
+                         * @member {replit.goval.api.lore.PartialUpdateMetadata|null|undefined} partialUpdateMetadata
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.partialUpdateMetadata = null;
+    
+                        /**
+                         * GovalCommand killRepl.
+                         * @member {replit.goval.api.lore.KillRepl|null|undefined} killRepl
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.killRepl = null;
+    
+                        /**
+                         * GovalCommand updateSourceRepl.
+                         * @member {replit.goval.api.lore.UpdateSourceRepl|null|undefined} updateSourceRepl
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.updateSourceRepl = null;
+    
+                        /**
+                         * GovalCommand updateReplFlags.
+                         * @member {replit.goval.api.lore.UpdateReplFlags|null|undefined} updateReplFlags
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.updateReplFlags = null;
+    
+                        /**
+                         * GovalCommand softTakedown.
+                         * @member {replit.goval.api.lore.SoftTakedown|null|undefined} softTakedown
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.softTakedown = null;
+    
+                        /**
+                         * GovalCommand takedown.
+                         * @member {replit.goval.api.lore.Takedown|null|undefined} takedown
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        GovalCommand.prototype.takedown = null;
+    
+                        // OneOf field names bound to virtual getters and setters
+                        var $oneOfFields;
+    
+                        /**
+                         * GovalCommand command.
+                         * @member {"updateMetadata"|"partialUpdateMetadata"|"killRepl"|"updateSourceRepl"|"updateReplFlags"|"softTakedown"|"takedown"|undefined} command
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         */
+                        Object.defineProperty(GovalCommand.prototype, "command", {
+                            get: $util.oneOfGetter($oneOfFields = ["updateMetadata", "partialUpdateMetadata", "killRepl", "updateSourceRepl", "updateReplFlags", "softTakedown", "takedown"]),
+                            set: $util.oneOfSetter($oneOfFields)
+                        });
+    
+                        /**
+                         * Creates a new GovalCommand instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.IGovalCommand=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.GovalCommand} GovalCommand instance
+                         */
+                        GovalCommand.create = function create(properties) {
+                            return GovalCommand.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified GovalCommand message. Does not implicitly {@link replit.goval.api.lore.GovalCommand.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.GovalCommand} message GovalCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        GovalCommand.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.updateMetadata != null && Object.hasOwnProperty.call(message, "updateMetadata"))
+                                $root.replit.goval.api.repl.Metadata.encode(message.updateMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.partialUpdateMetadata != null && Object.hasOwnProperty.call(message, "partialUpdateMetadata"))
+                                $root.replit.goval.api.lore.PartialUpdateMetadata.encode(message.partialUpdateMetadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            if (message.killRepl != null && Object.hasOwnProperty.call(message, "killRepl"))
+                                $root.replit.goval.api.lore.KillRepl.encode(message.killRepl, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+                            if (message.updateSourceRepl != null && Object.hasOwnProperty.call(message, "updateSourceRepl"))
+                                $root.replit.goval.api.lore.UpdateSourceRepl.encode(message.updateSourceRepl, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
+                            if (message.updateReplFlags != null && Object.hasOwnProperty.call(message, "updateReplFlags"))
+                                $root.replit.goval.api.lore.UpdateReplFlags.encode(message.updateReplFlags, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
+                            if (message.softTakedown != null && Object.hasOwnProperty.call(message, "softTakedown"))
+                                $root.replit.goval.api.lore.SoftTakedown.encode(message.softTakedown, writer.uint32(/* id 6, wireType 2 =*/50).fork()).ldelim();
+                            if (message.takedown != null && Object.hasOwnProperty.call(message, "takedown"))
+                                $root.replit.goval.api.lore.Takedown.encode(message.takedown, writer.uint32(/* id 7, wireType 2 =*/58).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified GovalCommand message, length delimited. Does not implicitly {@link replit.goval.api.lore.GovalCommand.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.GovalCommand} message GovalCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        GovalCommand.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a GovalCommand message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.GovalCommand} GovalCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        GovalCommand.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.GovalCommand();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.updateMetadata = $root.replit.goval.api.repl.Metadata.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    message.partialUpdateMetadata = $root.replit.goval.api.lore.PartialUpdateMetadata.decode(reader, reader.uint32());
+                                    break;
+                                case 3:
+                                    message.killRepl = $root.replit.goval.api.lore.KillRepl.decode(reader, reader.uint32());
+                                    break;
+                                case 4:
+                                    message.updateSourceRepl = $root.replit.goval.api.lore.UpdateSourceRepl.decode(reader, reader.uint32());
+                                    break;
+                                case 5:
+                                    message.updateReplFlags = $root.replit.goval.api.lore.UpdateReplFlags.decode(reader, reader.uint32());
+                                    break;
+                                case 6:
+                                    message.softTakedown = $root.replit.goval.api.lore.SoftTakedown.decode(reader, reader.uint32());
+                                    break;
+                                case 7:
+                                    message.takedown = $root.replit.goval.api.lore.Takedown.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a GovalCommand message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.GovalCommand} GovalCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        GovalCommand.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a GovalCommand message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        GovalCommand.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            var properties = {};
+                            if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata")) {
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.repl.Metadata.verify(message.updateMetadata);
+                                    if (error)
+                                        return "updateMetadata." + error;
+                                }
+                            }
+                            if (message.partialUpdateMetadata != null && message.hasOwnProperty("partialUpdateMetadata")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.PartialUpdateMetadata.verify(message.partialUpdateMetadata);
+                                    if (error)
+                                        return "partialUpdateMetadata." + error;
+                                }
+                            }
+                            if (message.killRepl != null && message.hasOwnProperty("killRepl")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.KillRepl.verify(message.killRepl);
+                                    if (error)
+                                        return "killRepl." + error;
+                                }
+                            }
+                            if (message.updateSourceRepl != null && message.hasOwnProperty("updateSourceRepl")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.UpdateSourceRepl.verify(message.updateSourceRepl);
+                                    if (error)
+                                        return "updateSourceRepl." + error;
+                                }
+                            }
+                            if (message.updateReplFlags != null && message.hasOwnProperty("updateReplFlags")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.UpdateReplFlags.verify(message.updateReplFlags);
+                                    if (error)
+                                        return "updateReplFlags." + error;
+                                }
+                            }
+                            if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.SoftTakedown.verify(message.softTakedown);
+                                    if (error)
+                                        return "softTakedown." + error;
+                                }
+                            }
+                            if (message.takedown != null && message.hasOwnProperty("takedown")) {
+                                if (properties.command === 1)
+                                    return "command: multiple values";
+                                properties.command = 1;
+                                {
+                                    var error = $root.replit.goval.api.lore.Takedown.verify(message.takedown);
+                                    if (error)
+                                        return "takedown." + error;
+                                }
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a GovalCommand message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.GovalCommand} GovalCommand
+                         */
+                        GovalCommand.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.GovalCommand)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.GovalCommand();
+                            if (object.updateMetadata != null) {
+                                if (typeof object.updateMetadata !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.updateMetadata: object expected");
+                                message.updateMetadata = $root.replit.goval.api.repl.Metadata.fromObject(object.updateMetadata);
+                            }
+                            if (object.partialUpdateMetadata != null) {
+                                if (typeof object.partialUpdateMetadata !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.partialUpdateMetadata: object expected");
+                                message.partialUpdateMetadata = $root.replit.goval.api.lore.PartialUpdateMetadata.fromObject(object.partialUpdateMetadata);
+                            }
+                            if (object.killRepl != null) {
+                                if (typeof object.killRepl !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.killRepl: object expected");
+                                message.killRepl = $root.replit.goval.api.lore.KillRepl.fromObject(object.killRepl);
+                            }
+                            if (object.updateSourceRepl != null) {
+                                if (typeof object.updateSourceRepl !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.updateSourceRepl: object expected");
+                                message.updateSourceRepl = $root.replit.goval.api.lore.UpdateSourceRepl.fromObject(object.updateSourceRepl);
+                            }
+                            if (object.updateReplFlags != null) {
+                                if (typeof object.updateReplFlags !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.updateReplFlags: object expected");
+                                message.updateReplFlags = $root.replit.goval.api.lore.UpdateReplFlags.fromObject(object.updateReplFlags);
+                            }
+                            if (object.softTakedown != null) {
+                                if (typeof object.softTakedown !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.softTakedown: object expected");
+                                message.softTakedown = $root.replit.goval.api.lore.SoftTakedown.fromObject(object.softTakedown);
+                            }
+                            if (object.takedown != null) {
+                                if (typeof object.takedown !== "object")
+                                    throw TypeError(".replit.goval.api.lore.GovalCommand.takedown: object expected");
+                                message.takedown = $root.replit.goval.api.lore.Takedown.fromObject(object.takedown);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a GovalCommand message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.GovalCommand} message GovalCommand
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        GovalCommand.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata")) {
+                                object.updateMetadata = $root.replit.goval.api.repl.Metadata.toObject(message.updateMetadata, options);
+                                if (options.oneofs)
+                                    object.command = "updateMetadata";
+                            }
+                            if (message.partialUpdateMetadata != null && message.hasOwnProperty("partialUpdateMetadata")) {
+                                object.partialUpdateMetadata = $root.replit.goval.api.lore.PartialUpdateMetadata.toObject(message.partialUpdateMetadata, options);
+                                if (options.oneofs)
+                                    object.command = "partialUpdateMetadata";
+                            }
+                            if (message.killRepl != null && message.hasOwnProperty("killRepl")) {
+                                object.killRepl = $root.replit.goval.api.lore.KillRepl.toObject(message.killRepl, options);
+                                if (options.oneofs)
+                                    object.command = "killRepl";
+                            }
+                            if (message.updateSourceRepl != null && message.hasOwnProperty("updateSourceRepl")) {
+                                object.updateSourceRepl = $root.replit.goval.api.lore.UpdateSourceRepl.toObject(message.updateSourceRepl, options);
+                                if (options.oneofs)
+                                    object.command = "updateSourceRepl";
+                            }
+                            if (message.updateReplFlags != null && message.hasOwnProperty("updateReplFlags")) {
+                                object.updateReplFlags = $root.replit.goval.api.lore.UpdateReplFlags.toObject(message.updateReplFlags, options);
+                                if (options.oneofs)
+                                    object.command = "updateReplFlags";
+                            }
+                            if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
+                                object.softTakedown = $root.replit.goval.api.lore.SoftTakedown.toObject(message.softTakedown, options);
+                                if (options.oneofs)
+                                    object.command = "softTakedown";
+                            }
+                            if (message.takedown != null && message.hasOwnProperty("takedown")) {
+                                object.takedown = $root.replit.goval.api.lore.Takedown.toObject(message.takedown, options);
+                                if (options.oneofs)
+                                    object.command = "takedown";
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this GovalCommand to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.GovalCommand
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        GovalCommand.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return GovalCommand;
+                    })();
+    
+                    lore.PartialUpdateMetadata = (function() {
+    
+                        /**
+                         * Properties of a PartialUpdateMetadata.
+                         * @memberof replit.goval.api.lore
+                         * @interface IPartialUpdateMetadata
+                         * @property {google.protobuf.FieldMask|google.protobuf.IFieldMask|null} [fieldMask] PartialUpdateMetadata fieldMask
+                         * @property {replit.goval.api.repl.Metadata|replit.goval.api.repl.IMetadata|null} [updateMetadata] PartialUpdateMetadata updateMetadata
+                         */
+    
+                        /**
+                         * Constructs a new PartialUpdateMetadata.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a PartialUpdateMetadata.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IPartialUpdateMetadata=} [properties] Properties to set
+                         */
+                        function PartialUpdateMetadata(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * PartialUpdateMetadata fieldMask.
+                         * @member {google.protobuf.FieldMask|null|undefined} fieldMask
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @instance
+                         */
+                        PartialUpdateMetadata.prototype.fieldMask = null;
+    
+                        /**
+                         * PartialUpdateMetadata updateMetadata.
+                         * @member {replit.goval.api.repl.Metadata|null|undefined} updateMetadata
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @instance
+                         */
+                        PartialUpdateMetadata.prototype.updateMetadata = null;
+    
+                        /**
+                         * Creates a new PartialUpdateMetadata instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {replit.goval.api.lore.IPartialUpdateMetadata=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.PartialUpdateMetadata} PartialUpdateMetadata instance
+                         */
+                        PartialUpdateMetadata.create = function create(properties) {
+                            return PartialUpdateMetadata.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified PartialUpdateMetadata message. Does not implicitly {@link replit.goval.api.lore.PartialUpdateMetadata.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {replit.goval.api.lore.PartialUpdateMetadata} message PartialUpdateMetadata message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        PartialUpdateMetadata.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.fieldMask != null && Object.hasOwnProperty.call(message, "fieldMask"))
+                                $root.google.protobuf.FieldMask.encode(message.fieldMask, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
+                            if (message.updateMetadata != null && Object.hasOwnProperty.call(message, "updateMetadata"))
+                                $root.replit.goval.api.repl.Metadata.encode(message.updateMetadata, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified PartialUpdateMetadata message, length delimited. Does not implicitly {@link replit.goval.api.lore.PartialUpdateMetadata.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {replit.goval.api.lore.PartialUpdateMetadata} message PartialUpdateMetadata message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        PartialUpdateMetadata.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a PartialUpdateMetadata message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.PartialUpdateMetadata} PartialUpdateMetadata
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        PartialUpdateMetadata.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.PartialUpdateMetadata();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.fieldMask = $root.google.protobuf.FieldMask.decode(reader, reader.uint32());
+                                    break;
+                                case 2:
+                                    message.updateMetadata = $root.replit.goval.api.repl.Metadata.decode(reader, reader.uint32());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a PartialUpdateMetadata message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.PartialUpdateMetadata} PartialUpdateMetadata
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        PartialUpdateMetadata.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a PartialUpdateMetadata message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        PartialUpdateMetadata.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.fieldMask != null && message.hasOwnProperty("fieldMask")) {
+                                var error = $root.google.protobuf.FieldMask.verify(message.fieldMask);
+                                if (error)
+                                    return "fieldMask." + error;
+                            }
+                            if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata")) {
+                                var error = $root.replit.goval.api.repl.Metadata.verify(message.updateMetadata);
+                                if (error)
+                                    return "updateMetadata." + error;
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a PartialUpdateMetadata message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.PartialUpdateMetadata} PartialUpdateMetadata
+                         */
+                        PartialUpdateMetadata.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.PartialUpdateMetadata)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.PartialUpdateMetadata();
+                            if (object.fieldMask != null) {
+                                if (typeof object.fieldMask !== "object")
+                                    throw TypeError(".replit.goval.api.lore.PartialUpdateMetadata.fieldMask: object expected");
+                                message.fieldMask = $root.google.protobuf.FieldMask.fromObject(object.fieldMask);
+                            }
+                            if (object.updateMetadata != null) {
+                                if (typeof object.updateMetadata !== "object")
+                                    throw TypeError(".replit.goval.api.lore.PartialUpdateMetadata.updateMetadata: object expected");
+                                message.updateMetadata = $root.replit.goval.api.repl.Metadata.fromObject(object.updateMetadata);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a PartialUpdateMetadata message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @static
+                         * @param {replit.goval.api.lore.PartialUpdateMetadata} message PartialUpdateMetadata
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        PartialUpdateMetadata.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.fieldMask = null;
+                                object.updateMetadata = null;
+                            }
+                            if (message.fieldMask != null && message.hasOwnProperty("fieldMask"))
+                                object.fieldMask = $root.google.protobuf.FieldMask.toObject(message.fieldMask, options);
+                            if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata"))
+                                object.updateMetadata = $root.replit.goval.api.repl.Metadata.toObject(message.updateMetadata, options);
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this PartialUpdateMetadata to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.PartialUpdateMetadata
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        PartialUpdateMetadata.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return PartialUpdateMetadata;
+                    })();
+    
+                    lore.MultiGovalCommand = (function() {
+    
+                        /**
+                         * Properties of a MultiGovalCommand.
+                         * @memberof replit.goval.api.lore
+                         * @interface IMultiGovalCommand
+                         * @property {string|null} [replId] MultiGovalCommand replId
+                         * @property {Array.<replit.goval.api.lore.GovalCommand|replit.goval.api.lore.IGovalCommand>|null} [govalCommands] MultiGovalCommand govalCommands
+                         */
+    
+                        /**
+                         * Constructs a new MultiGovalCommand.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a MultiGovalCommand.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IMultiGovalCommand=} [properties] Properties to set
+                         */
+                        function MultiGovalCommand(properties) {
+                            this.govalCommands = [];
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * MultiGovalCommand replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @instance
+                         */
+                        MultiGovalCommand.prototype.replId = "";
+    
+                        /**
+                         * MultiGovalCommand govalCommands.
+                         * @member {Array.<replit.goval.api.lore.GovalCommand>} govalCommands
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @instance
+                         */
+                        MultiGovalCommand.prototype.govalCommands = $util.emptyArray;
+    
+                        /**
+                         * Creates a new MultiGovalCommand instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.IMultiGovalCommand=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.MultiGovalCommand} MultiGovalCommand instance
+                         */
+                        MultiGovalCommand.create = function create(properties) {
+                            return MultiGovalCommand.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified MultiGovalCommand message. Does not implicitly {@link replit.goval.api.lore.MultiGovalCommand.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.MultiGovalCommand} message MultiGovalCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        MultiGovalCommand.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.govalCommands != null && message.govalCommands.length)
+                                for (var i = 0; i < message.govalCommands.length; ++i)
+                                    $root.replit.goval.api.lore.GovalCommand.encode(message.govalCommands[i], writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified MultiGovalCommand message, length delimited. Does not implicitly {@link replit.goval.api.lore.MultiGovalCommand.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.MultiGovalCommand} message MultiGovalCommand message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        MultiGovalCommand.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a MultiGovalCommand message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.MultiGovalCommand} MultiGovalCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        MultiGovalCommand.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.MultiGovalCommand();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    if (!(message.govalCommands && message.govalCommands.length))
+                                        message.govalCommands = [];
+                                    message.govalCommands.push($root.replit.goval.api.lore.GovalCommand.decode(reader, reader.uint32()));
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a MultiGovalCommand message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.MultiGovalCommand} MultiGovalCommand
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        MultiGovalCommand.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a MultiGovalCommand message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        MultiGovalCommand.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.govalCommands != null && message.hasOwnProperty("govalCommands")) {
+                                if (!Array.isArray(message.govalCommands))
+                                    return "govalCommands: array expected";
+                                for (var i = 0; i < message.govalCommands.length; ++i) {
+                                    var error = $root.replit.goval.api.lore.GovalCommand.verify(message.govalCommands[i]);
+                                    if (error)
+                                        return "govalCommands." + error;
+                                }
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a MultiGovalCommand message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.MultiGovalCommand} MultiGovalCommand
+                         */
+                        MultiGovalCommand.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.MultiGovalCommand)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.MultiGovalCommand();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.govalCommands) {
+                                if (!Array.isArray(object.govalCommands))
+                                    throw TypeError(".replit.goval.api.lore.MultiGovalCommand.govalCommands: array expected");
+                                message.govalCommands = [];
+                                for (var i = 0; i < object.govalCommands.length; ++i) {
+                                    if (typeof object.govalCommands[i] !== "object")
+                                        throw TypeError(".replit.goval.api.lore.MultiGovalCommand.govalCommands: object expected");
+                                    message.govalCommands[i] = $root.replit.goval.api.lore.GovalCommand.fromObject(object.govalCommands[i]);
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a MultiGovalCommand message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @static
+                         * @param {replit.goval.api.lore.MultiGovalCommand} message MultiGovalCommand
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        MultiGovalCommand.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.arrays || options.defaults)
+                                object.govalCommands = [];
+                            if (options.defaults)
+                                object.replId = "";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.govalCommands && message.govalCommands.length) {
+                                object.govalCommands = [];
+                                for (var j = 0; j < message.govalCommands.length; ++j)
+                                    object.govalCommands[j] = $root.replit.goval.api.lore.GovalCommand.toObject(message.govalCommands[j], options);
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this MultiGovalCommand to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.MultiGovalCommand
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        MultiGovalCommand.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return MultiGovalCommand;
+                    })();
+    
+                    lore.KillRepl = (function() {
+    
+                        /**
+                         * Properties of a KillRepl.
+                         * @memberof replit.goval.api.lore
+                         * @interface IKillRepl
+                         * @property {string|null} [replId] KillRepl replId
+                         */
+    
+                        /**
+                         * Constructs a new KillRepl.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a KillRepl.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IKillRepl=} [properties] Properties to set
+                         */
+                        function KillRepl(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * KillRepl replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @instance
+                         */
+                        KillRepl.prototype.replId = "";
+    
+                        /**
+                         * Creates a new KillRepl instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {replit.goval.api.lore.IKillRepl=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.KillRepl} KillRepl instance
+                         */
+                        KillRepl.create = function create(properties) {
+                            return KillRepl.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified KillRepl message. Does not implicitly {@link replit.goval.api.lore.KillRepl.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {replit.goval.api.lore.KillRepl} message KillRepl message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        KillRepl.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified KillRepl message, length delimited. Does not implicitly {@link replit.goval.api.lore.KillRepl.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {replit.goval.api.lore.KillRepl} message KillRepl message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        KillRepl.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a KillRepl message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.KillRepl} KillRepl
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        KillRepl.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.KillRepl();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a KillRepl message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.KillRepl} KillRepl
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        KillRepl.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a KillRepl message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        KillRepl.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a KillRepl message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.KillRepl} KillRepl
+                         */
+                        KillRepl.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.KillRepl)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.KillRepl();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a KillRepl message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @static
+                         * @param {replit.goval.api.lore.KillRepl} message KillRepl
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        KillRepl.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults)
+                                object.replId = "";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this KillRepl to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.KillRepl
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        KillRepl.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return KillRepl;
+                    })();
+    
+                    lore.Restore = (function() {
+    
+                        /**
+                         * Properties of a Restore.
+                         * @memberof replit.goval.api.lore
+                         * @interface IRestore
+                         * @property {string|null} [replId] Restore replId
+                         * @property {string|null} [restoreReplId] Restore restoreReplId
+                         */
+    
+                        /**
+                         * Constructs a new Restore.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents a Restore.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IRestore=} [properties] Properties to set
+                         */
+                        function Restore(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * Restore replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.Restore
+                         * @instance
+                         */
+                        Restore.prototype.replId = "";
+    
+                        /**
+                         * Restore restoreReplId.
+                         * @member {string} restoreReplId
+                         * @memberof replit.goval.api.lore.Restore
+                         * @instance
+                         */
+                        Restore.prototype.restoreReplId = "";
+    
+                        /**
+                         * Creates a new Restore instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {replit.goval.api.lore.IRestore=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.Restore} Restore instance
+                         */
+                        Restore.create = function create(properties) {
+                            return Restore.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified Restore message. Does not implicitly {@link replit.goval.api.lore.Restore.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {replit.goval.api.lore.Restore} message Restore message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        Restore.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.restoreReplId != null && Object.hasOwnProperty.call(message, "restoreReplId"))
+                                writer.uint32(/* id 2, wireType 2 =*/18).string(message.restoreReplId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified Restore message, length delimited. Does not implicitly {@link replit.goval.api.lore.Restore.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {replit.goval.api.lore.Restore} message Restore message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        Restore.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes a Restore message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.Restore} Restore
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        Restore.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.Restore();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    message.restoreReplId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes a Restore message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.Restore} Restore
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        Restore.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies a Restore message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        Restore.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.restoreReplId != null && message.hasOwnProperty("restoreReplId"))
+                                if (!$util.isString(message.restoreReplId))
+                                    return "restoreReplId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates a Restore message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.Restore} Restore
+                         */
+                        Restore.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.Restore)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.Restore();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.restoreReplId != null)
+                                message.restoreReplId = String(object.restoreReplId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from a Restore message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.Restore
+                         * @static
+                         * @param {replit.goval.api.lore.Restore} message Restore
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        Restore.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.replId = "";
+                                object.restoreReplId = "";
+                            }
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.restoreReplId != null && message.hasOwnProperty("restoreReplId"))
+                                object.restoreReplId = message.restoreReplId;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this Restore to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.Restore
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        Restore.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return Restore;
+                    })();
+    
+                    lore.UpdateSourceRepl = (function() {
+    
+                        /**
+                         * Properties of an UpdateSourceRepl.
+                         * @memberof replit.goval.api.lore
+                         * @interface IUpdateSourceRepl
+                         * @property {string|null} [replId] UpdateSourceRepl replId
+                         * @property {string|null} [sourceReplId] UpdateSourceRepl sourceReplId
+                         */
+    
+                        /**
+                         * Constructs a new UpdateSourceRepl.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents an UpdateSourceRepl.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IUpdateSourceRepl=} [properties] Properties to set
+                         */
+                        function UpdateSourceRepl(properties) {
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * UpdateSourceRepl replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @instance
+                         */
+                        UpdateSourceRepl.prototype.replId = "";
+    
+                        /**
+                         * UpdateSourceRepl sourceReplId.
+                         * @member {string} sourceReplId
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @instance
+                         */
+                        UpdateSourceRepl.prototype.sourceReplId = "";
+    
+                        /**
+                         * Creates a new UpdateSourceRepl instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {replit.goval.api.lore.IUpdateSourceRepl=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.UpdateSourceRepl} UpdateSourceRepl instance
+                         */
+                        UpdateSourceRepl.create = function create(properties) {
+                            return UpdateSourceRepl.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified UpdateSourceRepl message. Does not implicitly {@link replit.goval.api.lore.UpdateSourceRepl.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateSourceRepl} message UpdateSourceRepl message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UpdateSourceRepl.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.sourceReplId != null && Object.hasOwnProperty.call(message, "sourceReplId"))
+                                writer.uint32(/* id 2, wireType 2 =*/18).string(message.sourceReplId);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified UpdateSourceRepl message, length delimited. Does not implicitly {@link replit.goval.api.lore.UpdateSourceRepl.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateSourceRepl} message UpdateSourceRepl message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UpdateSourceRepl.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes an UpdateSourceRepl message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.UpdateSourceRepl} UpdateSourceRepl
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UpdateSourceRepl.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.UpdateSourceRepl();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    message.sourceReplId = reader.string();
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes an UpdateSourceRepl message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.UpdateSourceRepl} UpdateSourceRepl
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UpdateSourceRepl.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies an UpdateSourceRepl message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        UpdateSourceRepl.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.sourceReplId != null && message.hasOwnProperty("sourceReplId"))
+                                if (!$util.isString(message.sourceReplId))
+                                    return "sourceReplId: string expected";
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an UpdateSourceRepl message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.UpdateSourceRepl} UpdateSourceRepl
+                         */
+                        UpdateSourceRepl.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.UpdateSourceRepl)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.UpdateSourceRepl();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.sourceReplId != null)
+                                message.sourceReplId = String(object.sourceReplId);
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an UpdateSourceRepl message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateSourceRepl} message UpdateSourceRepl
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        UpdateSourceRepl.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.defaults) {
+                                object.replId = "";
+                                object.sourceReplId = "";
+                            }
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.sourceReplId != null && message.hasOwnProperty("sourceReplId"))
+                                object.sourceReplId = message.sourceReplId;
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this UpdateSourceRepl to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.UpdateSourceRepl
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        UpdateSourceRepl.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return UpdateSourceRepl;
+                    })();
+    
+                    lore.UpdateReplFlags = (function() {
+    
+                        /**
+                         * Properties of an UpdateReplFlags.
+                         * @memberof replit.goval.api.lore
+                         * @interface IUpdateReplFlags
+                         * @property {string|null} [replId] UpdateReplFlags replId
+                         * @property {Array.<string>|null} [flags] UpdateReplFlags flags
+                         */
+    
+                        /**
+                         * Constructs a new UpdateReplFlags.
+                         * @memberof replit.goval.api.lore
+                         * @classdesc Represents an UpdateReplFlags.
+                         * @constructor
+                         * @param {replit.goval.api.lore.IUpdateReplFlags=} [properties] Properties to set
+                         */
+                        function UpdateReplFlags(properties) {
+                            this.flags = [];
+                            if (properties)
+                                for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                                    if (properties[keys[i]] != null)
+                                        this[keys[i]] = properties[keys[i]];
+                        }
+    
+                        /**
+                         * UpdateReplFlags replId.
+                         * @member {string} replId
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @instance
+                         */
+                        UpdateReplFlags.prototype.replId = "";
+    
+                        /**
+                         * UpdateReplFlags flags.
+                         * @member {Array.<string>} flags
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @instance
+                         */
+                        UpdateReplFlags.prototype.flags = $util.emptyArray;
+    
+                        /**
+                         * Creates a new UpdateReplFlags instance using the specified properties.
+                         * @function create
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {replit.goval.api.lore.IUpdateReplFlags=} [properties] Properties to set
+                         * @returns {replit.goval.api.lore.UpdateReplFlags} UpdateReplFlags instance
+                         */
+                        UpdateReplFlags.create = function create(properties) {
+                            return UpdateReplFlags.fromObject(properties);
+                        };
+    
+                        /**
+                         * Encodes the specified UpdateReplFlags message. Does not implicitly {@link replit.goval.api.lore.UpdateReplFlags.verify|verify} messages.
+                         * @function encode
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateReplFlags} message UpdateReplFlags message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UpdateReplFlags.encode = function encode(message, writer) {
+                            if (!writer)
+                                writer = $Writer.create();
+                            if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
+                                writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
+                            if (message.flags != null && message.flags.length)
+                                for (var i = 0; i < message.flags.length; ++i)
+                                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.flags[i]);
+                            return writer;
+                        };
+    
+                        /**
+                         * Encodes the specified UpdateReplFlags message, length delimited. Does not implicitly {@link replit.goval.api.lore.UpdateReplFlags.verify|verify} messages.
+                         * @function encodeDelimited
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateReplFlags} message UpdateReplFlags message or plain object to encode
+                         * @param {$protobuf.Writer} [writer] Writer to encode to
+                         * @returns {$protobuf.Writer} Writer
+                         */
+                        UpdateReplFlags.encodeDelimited = function encodeDelimited(message, writer) {
+                            return this.encode(message, writer).ldelim();
+                        };
+    
+                        /**
+                         * Decodes an UpdateReplFlags message from the specified reader or buffer.
+                         * @function decode
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @param {number} [length] Message length if known beforehand
+                         * @returns {replit.goval.api.lore.UpdateReplFlags} UpdateReplFlags
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UpdateReplFlags.decode = function decode(reader, length) {
+                            if (!(reader instanceof $Reader))
+                                reader = $Reader.create(reader);
+                            var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.lore.UpdateReplFlags();
+                            while (reader.pos < end) {
+                                var tag = reader.uint32();
+                                switch (tag >>> 3) {
+                                case 1:
+                                    message.replId = reader.string();
+                                    break;
+                                case 2:
+                                    if (!(message.flags && message.flags.length))
+                                        message.flags = [];
+                                    message.flags.push(reader.string());
+                                    break;
+                                default:
+                                    reader.skipType(tag & 7);
+                                    break;
+                                }
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Decodes an UpdateReplFlags message from the specified reader or buffer, length delimited.
+                         * @function decodeDelimited
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                         * @returns {replit.goval.api.lore.UpdateReplFlags} UpdateReplFlags
+                         * @throws {Error} If the payload is not a reader or valid buffer
+                         * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                         */
+                        UpdateReplFlags.decodeDelimited = function decodeDelimited(reader) {
+                            if (!(reader instanceof $Reader))
+                                reader = new $Reader(reader);
+                            return this.decode(reader, reader.uint32());
+                        };
+    
+                        /**
+                         * Verifies an UpdateReplFlags message.
+                         * @function verify
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {Object.<string,*>} message Plain object to verify
+                         * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                         */
+                        UpdateReplFlags.verify = function verify(message) {
+                            if (typeof message !== "object" || message === null)
+                                return "object expected";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                if (!$util.isString(message.replId))
+                                    return "replId: string expected";
+                            if (message.flags != null && message.hasOwnProperty("flags")) {
+                                if (!Array.isArray(message.flags))
+                                    return "flags: array expected";
+                                for (var i = 0; i < message.flags.length; ++i)
+                                    if (!$util.isString(message.flags[i]))
+                                        return "flags: string[] expected";
+                            }
+                            return null;
+                        };
+    
+                        /**
+                         * Creates an UpdateReplFlags message from a plain object. Also converts values to their respective internal types.
+                         * @function fromObject
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {Object.<string,*>} object Plain object
+                         * @returns {replit.goval.api.lore.UpdateReplFlags} UpdateReplFlags
+                         */
+                        UpdateReplFlags.fromObject = function fromObject(object) {
+                            if (object instanceof $root.replit.goval.api.lore.UpdateReplFlags)
+                                return object;
+                            var message = new $root.replit.goval.api.lore.UpdateReplFlags();
+                            if (object.replId != null)
+                                message.replId = String(object.replId);
+                            if (object.flags) {
+                                if (!Array.isArray(object.flags))
+                                    throw TypeError(".replit.goval.api.lore.UpdateReplFlags.flags: array expected");
+                                message.flags = [];
+                                for (var i = 0; i < object.flags.length; ++i)
+                                    message.flags[i] = String(object.flags[i]);
+                            }
+                            return message;
+                        };
+    
+                        /**
+                         * Creates a plain object from an UpdateReplFlags message. Also converts values to other types if specified.
+                         * @function toObject
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @static
+                         * @param {replit.goval.api.lore.UpdateReplFlags} message UpdateReplFlags
+                         * @param {$protobuf.IConversionOptions} [options] Conversion options
+                         * @returns {Object.<string,*>} Plain object
+                         */
+                        UpdateReplFlags.toObject = function toObject(message, options) {
+                            if (!options)
+                                options = {};
+                            var object = {};
+                            if (options.arrays || options.defaults)
+                                object.flags = [];
+                            if (options.defaults)
+                                object.replId = "";
+                            if (message.replId != null && message.hasOwnProperty("replId"))
+                                object.replId = message.replId;
+                            if (message.flags && message.flags.length) {
+                                object.flags = [];
+                                for (var j = 0; j < message.flags.length; ++j)
+                                    object.flags[j] = message.flags[j];
+                            }
+                            return object;
+                        };
+    
+                        /**
+                         * Converts this UpdateReplFlags to JSON.
+                         * @function toJSON
+                         * @memberof replit.goval.api.lore.UpdateReplFlags
+                         * @instance
+                         * @returns {Object.<string,*>} JSON object
+                         */
+                        UpdateReplFlags.prototype.toJSON = function toJSON() {
+                            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                        };
+    
+                        return UpdateReplFlags;
+                    })();
+    
+                    return lore;
+                })();
+    
                 api.features = (function() {
     
                     /**
@@ -60038,6 +62817,208 @@
                 return ListValue;
             })();
     
+            protobuf.FieldMask = (function() {
+    
+                /**
+                 * Properties of a FieldMask.
+                 * @memberof google.protobuf
+                 * @interface IFieldMask
+                 * @property {Array.<string>|null} [paths] FieldMask paths
+                 */
+    
+                /**
+                 * Constructs a new FieldMask.
+                 * @memberof google.protobuf
+                 * @classdesc Represents a FieldMask.
+                 * @constructor
+                 * @param {google.protobuf.IFieldMask=} [properties] Properties to set
+                 */
+                function FieldMask(properties) {
+                    this.paths = [];
+                    if (properties)
+                        for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null)
+                                this[keys[i]] = properties[keys[i]];
+                }
+    
+                /**
+                 * FieldMask paths.
+                 * @member {Array.<string>} paths
+                 * @memberof google.protobuf.FieldMask
+                 * @instance
+                 */
+                FieldMask.prototype.paths = $util.emptyArray;
+    
+                /**
+                 * Creates a new FieldMask instance using the specified properties.
+                 * @function create
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {google.protobuf.IFieldMask=} [properties] Properties to set
+                 * @returns {google.protobuf.FieldMask} FieldMask instance
+                 */
+                FieldMask.create = function create(properties) {
+                    return FieldMask.fromObject(properties);
+                };
+    
+                /**
+                 * Encodes the specified FieldMask message. Does not implicitly {@link google.protobuf.FieldMask.verify|verify} messages.
+                 * @function encode
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {google.protobuf.FieldMask} message FieldMask message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                FieldMask.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.paths != null && message.paths.length)
+                        for (var i = 0; i < message.paths.length; ++i)
+                            writer.uint32(/* id 1, wireType 2 =*/10).string(message.paths[i]);
+                    return writer;
+                };
+    
+                /**
+                 * Encodes the specified FieldMask message, length delimited. Does not implicitly {@link google.protobuf.FieldMask.verify|verify} messages.
+                 * @function encodeDelimited
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {google.protobuf.FieldMask} message FieldMask message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                FieldMask.encodeDelimited = function encodeDelimited(message, writer) {
+                    return this.encode(message, writer).ldelim();
+                };
+    
+                /**
+                 * Decodes a FieldMask message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {google.protobuf.FieldMask} FieldMask
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                FieldMask.decode = function decode(reader, length) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    var end = length === undefined ? reader.len : reader.pos + length, message = new $root.google.protobuf.FieldMask();
+                    while (reader.pos < end) {
+                        var tag = reader.uint32();
+                        switch (tag >>> 3) {
+                        case 1:
+                            if (!(message.paths && message.paths.length))
+                                message.paths = [];
+                            message.paths.push(reader.string());
+                            break;
+                        default:
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Decodes a FieldMask message from the specified reader or buffer, length delimited.
+                 * @function decodeDelimited
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @returns {google.protobuf.FieldMask} FieldMask
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                FieldMask.decodeDelimited = function decodeDelimited(reader) {
+                    if (!(reader instanceof $Reader))
+                        reader = new $Reader(reader);
+                    return this.decode(reader, reader.uint32());
+                };
+    
+                /**
+                 * Verifies a FieldMask message.
+                 * @function verify
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                FieldMask.verify = function verify(message) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (message.paths != null && message.hasOwnProperty("paths")) {
+                        if (!Array.isArray(message.paths))
+                            return "paths: array expected";
+                        for (var i = 0; i < message.paths.length; ++i)
+                            if (!$util.isString(message.paths[i]))
+                                return "paths: string[] expected";
+                    }
+                    return null;
+                };
+    
+                /**
+                 * Creates a FieldMask message from a plain object. Also converts values to their respective internal types.
+                 * @function fromObject
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {Object.<string,*>} object Plain object
+                 * @returns {google.protobuf.FieldMask} FieldMask
+                 */
+                FieldMask.fromObject = function fromObject(object) {
+                    if (object instanceof $root.google.protobuf.FieldMask)
+                        return object;
+                    var message = new $root.google.protobuf.FieldMask();
+                    if (object.paths) {
+                        if (!Array.isArray(object.paths))
+                            throw TypeError(".google.protobuf.FieldMask.paths: array expected");
+                        message.paths = [];
+                        for (var i = 0; i < object.paths.length; ++i)
+                            message.paths[i] = String(object.paths[i]);
+                    }
+                    return message;
+                };
+    
+                /**
+                 * Creates a plain object from a FieldMask message. Also converts values to other types if specified.
+                 * @function toObject
+                 * @memberof google.protobuf.FieldMask
+                 * @static
+                 * @param {google.protobuf.FieldMask} message FieldMask
+                 * @param {$protobuf.IConversionOptions} [options] Conversion options
+                 * @returns {Object.<string,*>} Plain object
+                 */
+                FieldMask.toObject = function toObject(message, options) {
+                    if (!options)
+                        options = {};
+                    var object = {};
+                    if (options.arrays || options.defaults)
+                        object.paths = [];
+                    if (message.paths && message.paths.length) {
+                        object.paths = [];
+                        for (var j = 0; j < message.paths.length; ++j)
+                            object.paths[j] = message.paths[j];
+                    }
+                    return object;
+                };
+    
+                /**
+                 * Converts this FieldMask to JSON.
+                 * @function toJSON
+                 * @memberof google.protobuf.FieldMask
+                 * @instance
+                 * @returns {Object.<string,*>} JSON object
+                 */
+                FieldMask.prototype.toJSON = function toJSON() {
+                    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+                };
+    
+                return FieldMask;
+            })();
+    
             return protobuf;
         })();