@replit/protocol 0.2.75 → 0.2.76

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (4) hide show
  1. package/main/index.d.ts +504 -0
  2. package/main/index.js +1193 -0
  3. package/main/index.js.flow +712 -0
  4. package/package.json +2 -2
package/main/index.js CHANGED
@@ -48935,6 +48935,1199 @@
48935
48935
  return GovalReplIdentity;
48936
48936
  })();
48937
48937
 
48938
+ api.LoreCommand = (function() {
48939
+
48940
+ /**
48941
+ * Properties of a LoreCommand.
48942
+ * @memberof replit.goval.api
48943
+ * @interface ILoreCommand
48944
+ * @property {replit.goval.api.ClusterTransfer|replit.goval.api.IClusterTransfer|null} [clusterTransfer] LoreCommand clusterTransfer
48945
+ * @property {replit.goval.api.SoftTakedown|replit.goval.api.ISoftTakedown|null} [softTakedown] LoreCommand softTakedown
48946
+ * @property {replit.goval.api.GovalCommand|replit.goval.api.IGovalCommand|null} [govalCommand] LoreCommand govalCommand
48947
+ * @property {replit.goval.api.Restore|replit.goval.api.IRestore|null} [restore] LoreCommand restore
48948
+ */
48949
+
48950
+ /**
48951
+ * Constructs a new LoreCommand.
48952
+ * @memberof replit.goval.api
48953
+ * @classdesc Represents a LoreCommand.
48954
+ * @constructor
48955
+ * @param {replit.goval.api.ILoreCommand=} [properties] Properties to set
48956
+ */
48957
+ function LoreCommand(properties) {
48958
+ if (properties)
48959
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
48960
+ if (properties[keys[i]] != null)
48961
+ this[keys[i]] = properties[keys[i]];
48962
+ }
48963
+
48964
+ /**
48965
+ * LoreCommand clusterTransfer.
48966
+ * @member {replit.goval.api.ClusterTransfer|null|undefined} clusterTransfer
48967
+ * @memberof replit.goval.api.LoreCommand
48968
+ * @instance
48969
+ */
48970
+ LoreCommand.prototype.clusterTransfer = null;
48971
+
48972
+ /**
48973
+ * LoreCommand softTakedown.
48974
+ * @member {replit.goval.api.SoftTakedown|null|undefined} softTakedown
48975
+ * @memberof replit.goval.api.LoreCommand
48976
+ * @instance
48977
+ */
48978
+ LoreCommand.prototype.softTakedown = null;
48979
+
48980
+ /**
48981
+ * LoreCommand govalCommand.
48982
+ * @member {replit.goval.api.GovalCommand|null|undefined} govalCommand
48983
+ * @memberof replit.goval.api.LoreCommand
48984
+ * @instance
48985
+ */
48986
+ LoreCommand.prototype.govalCommand = null;
48987
+
48988
+ /**
48989
+ * LoreCommand restore.
48990
+ * @member {replit.goval.api.Restore|null|undefined} restore
48991
+ * @memberof replit.goval.api.LoreCommand
48992
+ * @instance
48993
+ */
48994
+ LoreCommand.prototype.restore = null;
48995
+
48996
+ // OneOf field names bound to virtual getters and setters
48997
+ var $oneOfFields;
48998
+
48999
+ /**
49000
+ * LoreCommand command.
49001
+ * @member {"clusterTransfer"|"softTakedown"|"govalCommand"|"restore"|undefined} command
49002
+ * @memberof replit.goval.api.LoreCommand
49003
+ * @instance
49004
+ */
49005
+ Object.defineProperty(LoreCommand.prototype, "command", {
49006
+ get: $util.oneOfGetter($oneOfFields = ["clusterTransfer", "softTakedown", "govalCommand", "restore"]),
49007
+ set: $util.oneOfSetter($oneOfFields)
49008
+ });
49009
+
49010
+ /**
49011
+ * Creates a new LoreCommand instance using the specified properties.
49012
+ * @function create
49013
+ * @memberof replit.goval.api.LoreCommand
49014
+ * @static
49015
+ * @param {replit.goval.api.ILoreCommand=} [properties] Properties to set
49016
+ * @returns {replit.goval.api.LoreCommand} LoreCommand instance
49017
+ */
49018
+ LoreCommand.create = function create(properties) {
49019
+ return LoreCommand.fromObject(properties);
49020
+ };
49021
+
49022
+ /**
49023
+ * Encodes the specified LoreCommand message. Does not implicitly {@link replit.goval.api.LoreCommand.verify|verify} messages.
49024
+ * @function encode
49025
+ * @memberof replit.goval.api.LoreCommand
49026
+ * @static
49027
+ * @param {replit.goval.api.LoreCommand} message LoreCommand message or plain object to encode
49028
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49029
+ * @returns {$protobuf.Writer} Writer
49030
+ */
49031
+ LoreCommand.encode = function encode(message, writer) {
49032
+ if (!writer)
49033
+ writer = $Writer.create();
49034
+ if (message.clusterTransfer != null && Object.hasOwnProperty.call(message, "clusterTransfer"))
49035
+ $root.replit.goval.api.ClusterTransfer.encode(message.clusterTransfer, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
49036
+ if (message.softTakedown != null && Object.hasOwnProperty.call(message, "softTakedown"))
49037
+ $root.replit.goval.api.SoftTakedown.encode(message.softTakedown, writer.uint32(/* id 2, wireType 2 =*/18).fork()).ldelim();
49038
+ if (message.govalCommand != null && Object.hasOwnProperty.call(message, "govalCommand"))
49039
+ $root.replit.goval.api.GovalCommand.encode(message.govalCommand, writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
49040
+ if (message.restore != null && Object.hasOwnProperty.call(message, "restore"))
49041
+ $root.replit.goval.api.Restore.encode(message.restore, writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
49042
+ return writer;
49043
+ };
49044
+
49045
+ /**
49046
+ * Encodes the specified LoreCommand message, length delimited. Does not implicitly {@link replit.goval.api.LoreCommand.verify|verify} messages.
49047
+ * @function encodeDelimited
49048
+ * @memberof replit.goval.api.LoreCommand
49049
+ * @static
49050
+ * @param {replit.goval.api.LoreCommand} message LoreCommand message or plain object to encode
49051
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49052
+ * @returns {$protobuf.Writer} Writer
49053
+ */
49054
+ LoreCommand.encodeDelimited = function encodeDelimited(message, writer) {
49055
+ return this.encode(message, writer).ldelim();
49056
+ };
49057
+
49058
+ /**
49059
+ * Decodes a LoreCommand message from the specified reader or buffer.
49060
+ * @function decode
49061
+ * @memberof replit.goval.api.LoreCommand
49062
+ * @static
49063
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49064
+ * @param {number} [length] Message length if known beforehand
49065
+ * @returns {replit.goval.api.LoreCommand} LoreCommand
49066
+ * @throws {Error} If the payload is not a reader or valid buffer
49067
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49068
+ */
49069
+ LoreCommand.decode = function decode(reader, length) {
49070
+ if (!(reader instanceof $Reader))
49071
+ reader = $Reader.create(reader);
49072
+ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.LoreCommand();
49073
+ while (reader.pos < end) {
49074
+ var tag = reader.uint32();
49075
+ switch (tag >>> 3) {
49076
+ case 1:
49077
+ message.clusterTransfer = $root.replit.goval.api.ClusterTransfer.decode(reader, reader.uint32());
49078
+ break;
49079
+ case 2:
49080
+ message.softTakedown = $root.replit.goval.api.SoftTakedown.decode(reader, reader.uint32());
49081
+ break;
49082
+ case 3:
49083
+ message.govalCommand = $root.replit.goval.api.GovalCommand.decode(reader, reader.uint32());
49084
+ break;
49085
+ case 4:
49086
+ message.restore = $root.replit.goval.api.Restore.decode(reader, reader.uint32());
49087
+ break;
49088
+ default:
49089
+ reader.skipType(tag & 7);
49090
+ break;
49091
+ }
49092
+ }
49093
+ return message;
49094
+ };
49095
+
49096
+ /**
49097
+ * Decodes a LoreCommand message from the specified reader or buffer, length delimited.
49098
+ * @function decodeDelimited
49099
+ * @memberof replit.goval.api.LoreCommand
49100
+ * @static
49101
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49102
+ * @returns {replit.goval.api.LoreCommand} LoreCommand
49103
+ * @throws {Error} If the payload is not a reader or valid buffer
49104
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49105
+ */
49106
+ LoreCommand.decodeDelimited = function decodeDelimited(reader) {
49107
+ if (!(reader instanceof $Reader))
49108
+ reader = new $Reader(reader);
49109
+ return this.decode(reader, reader.uint32());
49110
+ };
49111
+
49112
+ /**
49113
+ * Verifies a LoreCommand message.
49114
+ * @function verify
49115
+ * @memberof replit.goval.api.LoreCommand
49116
+ * @static
49117
+ * @param {Object.<string,*>} message Plain object to verify
49118
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
49119
+ */
49120
+ LoreCommand.verify = function verify(message) {
49121
+ if (typeof message !== "object" || message === null)
49122
+ return "object expected";
49123
+ var properties = {};
49124
+ if (message.clusterTransfer != null && message.hasOwnProperty("clusterTransfer")) {
49125
+ properties.command = 1;
49126
+ {
49127
+ var error = $root.replit.goval.api.ClusterTransfer.verify(message.clusterTransfer);
49128
+ if (error)
49129
+ return "clusterTransfer." + error;
49130
+ }
49131
+ }
49132
+ if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
49133
+ if (properties.command === 1)
49134
+ return "command: multiple values";
49135
+ properties.command = 1;
49136
+ {
49137
+ var error = $root.replit.goval.api.SoftTakedown.verify(message.softTakedown);
49138
+ if (error)
49139
+ return "softTakedown." + error;
49140
+ }
49141
+ }
49142
+ if (message.govalCommand != null && message.hasOwnProperty("govalCommand")) {
49143
+ if (properties.command === 1)
49144
+ return "command: multiple values";
49145
+ properties.command = 1;
49146
+ {
49147
+ var error = $root.replit.goval.api.GovalCommand.verify(message.govalCommand);
49148
+ if (error)
49149
+ return "govalCommand." + error;
49150
+ }
49151
+ }
49152
+ if (message.restore != null && message.hasOwnProperty("restore")) {
49153
+ if (properties.command === 1)
49154
+ return "command: multiple values";
49155
+ properties.command = 1;
49156
+ {
49157
+ var error = $root.replit.goval.api.Restore.verify(message.restore);
49158
+ if (error)
49159
+ return "restore." + error;
49160
+ }
49161
+ }
49162
+ return null;
49163
+ };
49164
+
49165
+ /**
49166
+ * Creates a LoreCommand message from a plain object. Also converts values to their respective internal types.
49167
+ * @function fromObject
49168
+ * @memberof replit.goval.api.LoreCommand
49169
+ * @static
49170
+ * @param {Object.<string,*>} object Plain object
49171
+ * @returns {replit.goval.api.LoreCommand} LoreCommand
49172
+ */
49173
+ LoreCommand.fromObject = function fromObject(object) {
49174
+ if (object instanceof $root.replit.goval.api.LoreCommand)
49175
+ return object;
49176
+ var message = new $root.replit.goval.api.LoreCommand();
49177
+ if (object.clusterTransfer != null) {
49178
+ if (typeof object.clusterTransfer !== "object")
49179
+ throw TypeError(".replit.goval.api.LoreCommand.clusterTransfer: object expected");
49180
+ message.clusterTransfer = $root.replit.goval.api.ClusterTransfer.fromObject(object.clusterTransfer);
49181
+ }
49182
+ if (object.softTakedown != null) {
49183
+ if (typeof object.softTakedown !== "object")
49184
+ throw TypeError(".replit.goval.api.LoreCommand.softTakedown: object expected");
49185
+ message.softTakedown = $root.replit.goval.api.SoftTakedown.fromObject(object.softTakedown);
49186
+ }
49187
+ if (object.govalCommand != null) {
49188
+ if (typeof object.govalCommand !== "object")
49189
+ throw TypeError(".replit.goval.api.LoreCommand.govalCommand: object expected");
49190
+ message.govalCommand = $root.replit.goval.api.GovalCommand.fromObject(object.govalCommand);
49191
+ }
49192
+ if (object.restore != null) {
49193
+ if (typeof object.restore !== "object")
49194
+ throw TypeError(".replit.goval.api.LoreCommand.restore: object expected");
49195
+ message.restore = $root.replit.goval.api.Restore.fromObject(object.restore);
49196
+ }
49197
+ return message;
49198
+ };
49199
+
49200
+ /**
49201
+ * Creates a plain object from a LoreCommand message. Also converts values to other types if specified.
49202
+ * @function toObject
49203
+ * @memberof replit.goval.api.LoreCommand
49204
+ * @static
49205
+ * @param {replit.goval.api.LoreCommand} message LoreCommand
49206
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
49207
+ * @returns {Object.<string,*>} Plain object
49208
+ */
49209
+ LoreCommand.toObject = function toObject(message, options) {
49210
+ if (!options)
49211
+ options = {};
49212
+ var object = {};
49213
+ if (message.clusterTransfer != null && message.hasOwnProperty("clusterTransfer")) {
49214
+ object.clusterTransfer = $root.replit.goval.api.ClusterTransfer.toObject(message.clusterTransfer, options);
49215
+ if (options.oneofs)
49216
+ object.command = "clusterTransfer";
49217
+ }
49218
+ if (message.softTakedown != null && message.hasOwnProperty("softTakedown")) {
49219
+ object.softTakedown = $root.replit.goval.api.SoftTakedown.toObject(message.softTakedown, options);
49220
+ if (options.oneofs)
49221
+ object.command = "softTakedown";
49222
+ }
49223
+ if (message.govalCommand != null && message.hasOwnProperty("govalCommand")) {
49224
+ object.govalCommand = $root.replit.goval.api.GovalCommand.toObject(message.govalCommand, options);
49225
+ if (options.oneofs)
49226
+ object.command = "govalCommand";
49227
+ }
49228
+ if (message.restore != null && message.hasOwnProperty("restore")) {
49229
+ object.restore = $root.replit.goval.api.Restore.toObject(message.restore, options);
49230
+ if (options.oneofs)
49231
+ object.command = "restore";
49232
+ }
49233
+ return object;
49234
+ };
49235
+
49236
+ /**
49237
+ * Converts this LoreCommand to JSON.
49238
+ * @function toJSON
49239
+ * @memberof replit.goval.api.LoreCommand
49240
+ * @instance
49241
+ * @returns {Object.<string,*>} JSON object
49242
+ */
49243
+ LoreCommand.prototype.toJSON = function toJSON() {
49244
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
49245
+ };
49246
+
49247
+ return LoreCommand;
49248
+ })();
49249
+
49250
+ api.ClusterTransfer = (function() {
49251
+
49252
+ /**
49253
+ * Properties of a ClusterTransfer.
49254
+ * @memberof replit.goval.api
49255
+ * @interface IClusterTransfer
49256
+ * @property {string|null} [replId] ClusterTransfer replId
49257
+ * @property {string|null} [user] ClusterTransfer user
49258
+ * @property {string|null} [newClusterId] ClusterTransfer newClusterId
49259
+ * @property {string|null} [transferId] ClusterTransfer transferId
49260
+ */
49261
+
49262
+ /**
49263
+ * Constructs a new ClusterTransfer.
49264
+ * @memberof replit.goval.api
49265
+ * @classdesc Represents a ClusterTransfer.
49266
+ * @constructor
49267
+ * @param {replit.goval.api.IClusterTransfer=} [properties] Properties to set
49268
+ */
49269
+ function ClusterTransfer(properties) {
49270
+ if (properties)
49271
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
49272
+ if (properties[keys[i]] != null)
49273
+ this[keys[i]] = properties[keys[i]];
49274
+ }
49275
+
49276
+ /**
49277
+ * ClusterTransfer replId.
49278
+ * @member {string} replId
49279
+ * @memberof replit.goval.api.ClusterTransfer
49280
+ * @instance
49281
+ */
49282
+ ClusterTransfer.prototype.replId = "";
49283
+
49284
+ /**
49285
+ * ClusterTransfer user.
49286
+ * @member {string} user
49287
+ * @memberof replit.goval.api.ClusterTransfer
49288
+ * @instance
49289
+ */
49290
+ ClusterTransfer.prototype.user = "";
49291
+
49292
+ /**
49293
+ * ClusterTransfer newClusterId.
49294
+ * @member {string} newClusterId
49295
+ * @memberof replit.goval.api.ClusterTransfer
49296
+ * @instance
49297
+ */
49298
+ ClusterTransfer.prototype.newClusterId = "";
49299
+
49300
+ /**
49301
+ * ClusterTransfer transferId.
49302
+ * @member {string} transferId
49303
+ * @memberof replit.goval.api.ClusterTransfer
49304
+ * @instance
49305
+ */
49306
+ ClusterTransfer.prototype.transferId = "";
49307
+
49308
+ /**
49309
+ * Creates a new ClusterTransfer instance using the specified properties.
49310
+ * @function create
49311
+ * @memberof replit.goval.api.ClusterTransfer
49312
+ * @static
49313
+ * @param {replit.goval.api.IClusterTransfer=} [properties] Properties to set
49314
+ * @returns {replit.goval.api.ClusterTransfer} ClusterTransfer instance
49315
+ */
49316
+ ClusterTransfer.create = function create(properties) {
49317
+ return ClusterTransfer.fromObject(properties);
49318
+ };
49319
+
49320
+ /**
49321
+ * Encodes the specified ClusterTransfer message. Does not implicitly {@link replit.goval.api.ClusterTransfer.verify|verify} messages.
49322
+ * @function encode
49323
+ * @memberof replit.goval.api.ClusterTransfer
49324
+ * @static
49325
+ * @param {replit.goval.api.ClusterTransfer} message ClusterTransfer message or plain object to encode
49326
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49327
+ * @returns {$protobuf.Writer} Writer
49328
+ */
49329
+ ClusterTransfer.encode = function encode(message, writer) {
49330
+ if (!writer)
49331
+ writer = $Writer.create();
49332
+ if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
49333
+ writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
49334
+ if (message.user != null && Object.hasOwnProperty.call(message, "user"))
49335
+ writer.uint32(/* id 2, wireType 2 =*/18).string(message.user);
49336
+ if (message.newClusterId != null && Object.hasOwnProperty.call(message, "newClusterId"))
49337
+ writer.uint32(/* id 3, wireType 2 =*/26).string(message.newClusterId);
49338
+ if (message.transferId != null && Object.hasOwnProperty.call(message, "transferId"))
49339
+ writer.uint32(/* id 4, wireType 2 =*/34).string(message.transferId);
49340
+ return writer;
49341
+ };
49342
+
49343
+ /**
49344
+ * Encodes the specified ClusterTransfer message, length delimited. Does not implicitly {@link replit.goval.api.ClusterTransfer.verify|verify} messages.
49345
+ * @function encodeDelimited
49346
+ * @memberof replit.goval.api.ClusterTransfer
49347
+ * @static
49348
+ * @param {replit.goval.api.ClusterTransfer} message ClusterTransfer message or plain object to encode
49349
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49350
+ * @returns {$protobuf.Writer} Writer
49351
+ */
49352
+ ClusterTransfer.encodeDelimited = function encodeDelimited(message, writer) {
49353
+ return this.encode(message, writer).ldelim();
49354
+ };
49355
+
49356
+ /**
49357
+ * Decodes a ClusterTransfer message from the specified reader or buffer.
49358
+ * @function decode
49359
+ * @memberof replit.goval.api.ClusterTransfer
49360
+ * @static
49361
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49362
+ * @param {number} [length] Message length if known beforehand
49363
+ * @returns {replit.goval.api.ClusterTransfer} ClusterTransfer
49364
+ * @throws {Error} If the payload is not a reader or valid buffer
49365
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49366
+ */
49367
+ ClusterTransfer.decode = function decode(reader, length) {
49368
+ if (!(reader instanceof $Reader))
49369
+ reader = $Reader.create(reader);
49370
+ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.ClusterTransfer();
49371
+ while (reader.pos < end) {
49372
+ var tag = reader.uint32();
49373
+ switch (tag >>> 3) {
49374
+ case 1:
49375
+ message.replId = reader.string();
49376
+ break;
49377
+ case 2:
49378
+ message.user = reader.string();
49379
+ break;
49380
+ case 3:
49381
+ message.newClusterId = reader.string();
49382
+ break;
49383
+ case 4:
49384
+ message.transferId = reader.string();
49385
+ break;
49386
+ default:
49387
+ reader.skipType(tag & 7);
49388
+ break;
49389
+ }
49390
+ }
49391
+ return message;
49392
+ };
49393
+
49394
+ /**
49395
+ * Decodes a ClusterTransfer message from the specified reader or buffer, length delimited.
49396
+ * @function decodeDelimited
49397
+ * @memberof replit.goval.api.ClusterTransfer
49398
+ * @static
49399
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49400
+ * @returns {replit.goval.api.ClusterTransfer} ClusterTransfer
49401
+ * @throws {Error} If the payload is not a reader or valid buffer
49402
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49403
+ */
49404
+ ClusterTransfer.decodeDelimited = function decodeDelimited(reader) {
49405
+ if (!(reader instanceof $Reader))
49406
+ reader = new $Reader(reader);
49407
+ return this.decode(reader, reader.uint32());
49408
+ };
49409
+
49410
+ /**
49411
+ * Verifies a ClusterTransfer message.
49412
+ * @function verify
49413
+ * @memberof replit.goval.api.ClusterTransfer
49414
+ * @static
49415
+ * @param {Object.<string,*>} message Plain object to verify
49416
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
49417
+ */
49418
+ ClusterTransfer.verify = function verify(message) {
49419
+ if (typeof message !== "object" || message === null)
49420
+ return "object expected";
49421
+ if (message.replId != null && message.hasOwnProperty("replId"))
49422
+ if (!$util.isString(message.replId))
49423
+ return "replId: string expected";
49424
+ if (message.user != null && message.hasOwnProperty("user"))
49425
+ if (!$util.isString(message.user))
49426
+ return "user: string expected";
49427
+ if (message.newClusterId != null && message.hasOwnProperty("newClusterId"))
49428
+ if (!$util.isString(message.newClusterId))
49429
+ return "newClusterId: string expected";
49430
+ if (message.transferId != null && message.hasOwnProperty("transferId"))
49431
+ if (!$util.isString(message.transferId))
49432
+ return "transferId: string expected";
49433
+ return null;
49434
+ };
49435
+
49436
+ /**
49437
+ * Creates a ClusterTransfer message from a plain object. Also converts values to their respective internal types.
49438
+ * @function fromObject
49439
+ * @memberof replit.goval.api.ClusterTransfer
49440
+ * @static
49441
+ * @param {Object.<string,*>} object Plain object
49442
+ * @returns {replit.goval.api.ClusterTransfer} ClusterTransfer
49443
+ */
49444
+ ClusterTransfer.fromObject = function fromObject(object) {
49445
+ if (object instanceof $root.replit.goval.api.ClusterTransfer)
49446
+ return object;
49447
+ var message = new $root.replit.goval.api.ClusterTransfer();
49448
+ if (object.replId != null)
49449
+ message.replId = String(object.replId);
49450
+ if (object.user != null)
49451
+ message.user = String(object.user);
49452
+ if (object.newClusterId != null)
49453
+ message.newClusterId = String(object.newClusterId);
49454
+ if (object.transferId != null)
49455
+ message.transferId = String(object.transferId);
49456
+ return message;
49457
+ };
49458
+
49459
+ /**
49460
+ * Creates a plain object from a ClusterTransfer message. Also converts values to other types if specified.
49461
+ * @function toObject
49462
+ * @memberof replit.goval.api.ClusterTransfer
49463
+ * @static
49464
+ * @param {replit.goval.api.ClusterTransfer} message ClusterTransfer
49465
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
49466
+ * @returns {Object.<string,*>} Plain object
49467
+ */
49468
+ ClusterTransfer.toObject = function toObject(message, options) {
49469
+ if (!options)
49470
+ options = {};
49471
+ var object = {};
49472
+ if (options.defaults) {
49473
+ object.replId = "";
49474
+ object.user = "";
49475
+ object.newClusterId = "";
49476
+ object.transferId = "";
49477
+ }
49478
+ if (message.replId != null && message.hasOwnProperty("replId"))
49479
+ object.replId = message.replId;
49480
+ if (message.user != null && message.hasOwnProperty("user"))
49481
+ object.user = message.user;
49482
+ if (message.newClusterId != null && message.hasOwnProperty("newClusterId"))
49483
+ object.newClusterId = message.newClusterId;
49484
+ if (message.transferId != null && message.hasOwnProperty("transferId"))
49485
+ object.transferId = message.transferId;
49486
+ return object;
49487
+ };
49488
+
49489
+ /**
49490
+ * Converts this ClusterTransfer to JSON.
49491
+ * @function toJSON
49492
+ * @memberof replit.goval.api.ClusterTransfer
49493
+ * @instance
49494
+ * @returns {Object.<string,*>} JSON object
49495
+ */
49496
+ ClusterTransfer.prototype.toJSON = function toJSON() {
49497
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
49498
+ };
49499
+
49500
+ return ClusterTransfer;
49501
+ })();
49502
+
49503
+ api.SoftTakedown = (function() {
49504
+
49505
+ /**
49506
+ * Properties of a SoftTakedown.
49507
+ * @memberof replit.goval.api
49508
+ * @interface ISoftTakedown
49509
+ * @property {string|null} [replId] SoftTakedown replId
49510
+ * @property {string|null} [softTakedownId] SoftTakedown softTakedownId
49511
+ */
49512
+
49513
+ /**
49514
+ * Constructs a new SoftTakedown.
49515
+ * @memberof replit.goval.api
49516
+ * @classdesc Represents a SoftTakedown.
49517
+ * @constructor
49518
+ * @param {replit.goval.api.ISoftTakedown=} [properties] Properties to set
49519
+ */
49520
+ function SoftTakedown(properties) {
49521
+ if (properties)
49522
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
49523
+ if (properties[keys[i]] != null)
49524
+ this[keys[i]] = properties[keys[i]];
49525
+ }
49526
+
49527
+ /**
49528
+ * SoftTakedown replId.
49529
+ * @member {string} replId
49530
+ * @memberof replit.goval.api.SoftTakedown
49531
+ * @instance
49532
+ */
49533
+ SoftTakedown.prototype.replId = "";
49534
+
49535
+ /**
49536
+ * SoftTakedown softTakedownId.
49537
+ * @member {string} softTakedownId
49538
+ * @memberof replit.goval.api.SoftTakedown
49539
+ * @instance
49540
+ */
49541
+ SoftTakedown.prototype.softTakedownId = "";
49542
+
49543
+ /**
49544
+ * Creates a new SoftTakedown instance using the specified properties.
49545
+ * @function create
49546
+ * @memberof replit.goval.api.SoftTakedown
49547
+ * @static
49548
+ * @param {replit.goval.api.ISoftTakedown=} [properties] Properties to set
49549
+ * @returns {replit.goval.api.SoftTakedown} SoftTakedown instance
49550
+ */
49551
+ SoftTakedown.create = function create(properties) {
49552
+ return SoftTakedown.fromObject(properties);
49553
+ };
49554
+
49555
+ /**
49556
+ * Encodes the specified SoftTakedown message. Does not implicitly {@link replit.goval.api.SoftTakedown.verify|verify} messages.
49557
+ * @function encode
49558
+ * @memberof replit.goval.api.SoftTakedown
49559
+ * @static
49560
+ * @param {replit.goval.api.SoftTakedown} message SoftTakedown message or plain object to encode
49561
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49562
+ * @returns {$protobuf.Writer} Writer
49563
+ */
49564
+ SoftTakedown.encode = function encode(message, writer) {
49565
+ if (!writer)
49566
+ writer = $Writer.create();
49567
+ if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
49568
+ writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
49569
+ if (message.softTakedownId != null && Object.hasOwnProperty.call(message, "softTakedownId"))
49570
+ writer.uint32(/* id 2, wireType 2 =*/18).string(message.softTakedownId);
49571
+ return writer;
49572
+ };
49573
+
49574
+ /**
49575
+ * Encodes the specified SoftTakedown message, length delimited. Does not implicitly {@link replit.goval.api.SoftTakedown.verify|verify} messages.
49576
+ * @function encodeDelimited
49577
+ * @memberof replit.goval.api.SoftTakedown
49578
+ * @static
49579
+ * @param {replit.goval.api.SoftTakedown} message SoftTakedown message or plain object to encode
49580
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49581
+ * @returns {$protobuf.Writer} Writer
49582
+ */
49583
+ SoftTakedown.encodeDelimited = function encodeDelimited(message, writer) {
49584
+ return this.encode(message, writer).ldelim();
49585
+ };
49586
+
49587
+ /**
49588
+ * Decodes a SoftTakedown message from the specified reader or buffer.
49589
+ * @function decode
49590
+ * @memberof replit.goval.api.SoftTakedown
49591
+ * @static
49592
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49593
+ * @param {number} [length] Message length if known beforehand
49594
+ * @returns {replit.goval.api.SoftTakedown} SoftTakedown
49595
+ * @throws {Error} If the payload is not a reader or valid buffer
49596
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49597
+ */
49598
+ SoftTakedown.decode = function decode(reader, length) {
49599
+ if (!(reader instanceof $Reader))
49600
+ reader = $Reader.create(reader);
49601
+ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.SoftTakedown();
49602
+ while (reader.pos < end) {
49603
+ var tag = reader.uint32();
49604
+ switch (tag >>> 3) {
49605
+ case 1:
49606
+ message.replId = reader.string();
49607
+ break;
49608
+ case 2:
49609
+ message.softTakedownId = reader.string();
49610
+ break;
49611
+ default:
49612
+ reader.skipType(tag & 7);
49613
+ break;
49614
+ }
49615
+ }
49616
+ return message;
49617
+ };
49618
+
49619
+ /**
49620
+ * Decodes a SoftTakedown message from the specified reader or buffer, length delimited.
49621
+ * @function decodeDelimited
49622
+ * @memberof replit.goval.api.SoftTakedown
49623
+ * @static
49624
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49625
+ * @returns {replit.goval.api.SoftTakedown} SoftTakedown
49626
+ * @throws {Error} If the payload is not a reader or valid buffer
49627
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49628
+ */
49629
+ SoftTakedown.decodeDelimited = function decodeDelimited(reader) {
49630
+ if (!(reader instanceof $Reader))
49631
+ reader = new $Reader(reader);
49632
+ return this.decode(reader, reader.uint32());
49633
+ };
49634
+
49635
+ /**
49636
+ * Verifies a SoftTakedown message.
49637
+ * @function verify
49638
+ * @memberof replit.goval.api.SoftTakedown
49639
+ * @static
49640
+ * @param {Object.<string,*>} message Plain object to verify
49641
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
49642
+ */
49643
+ SoftTakedown.verify = function verify(message) {
49644
+ if (typeof message !== "object" || message === null)
49645
+ return "object expected";
49646
+ if (message.replId != null && message.hasOwnProperty("replId"))
49647
+ if (!$util.isString(message.replId))
49648
+ return "replId: string expected";
49649
+ if (message.softTakedownId != null && message.hasOwnProperty("softTakedownId"))
49650
+ if (!$util.isString(message.softTakedownId))
49651
+ return "softTakedownId: string expected";
49652
+ return null;
49653
+ };
49654
+
49655
+ /**
49656
+ * Creates a SoftTakedown message from a plain object. Also converts values to their respective internal types.
49657
+ * @function fromObject
49658
+ * @memberof replit.goval.api.SoftTakedown
49659
+ * @static
49660
+ * @param {Object.<string,*>} object Plain object
49661
+ * @returns {replit.goval.api.SoftTakedown} SoftTakedown
49662
+ */
49663
+ SoftTakedown.fromObject = function fromObject(object) {
49664
+ if (object instanceof $root.replit.goval.api.SoftTakedown)
49665
+ return object;
49666
+ var message = new $root.replit.goval.api.SoftTakedown();
49667
+ if (object.replId != null)
49668
+ message.replId = String(object.replId);
49669
+ if (object.softTakedownId != null)
49670
+ message.softTakedownId = String(object.softTakedownId);
49671
+ return message;
49672
+ };
49673
+
49674
+ /**
49675
+ * Creates a plain object from a SoftTakedown message. Also converts values to other types if specified.
49676
+ * @function toObject
49677
+ * @memberof replit.goval.api.SoftTakedown
49678
+ * @static
49679
+ * @param {replit.goval.api.SoftTakedown} message SoftTakedown
49680
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
49681
+ * @returns {Object.<string,*>} Plain object
49682
+ */
49683
+ SoftTakedown.toObject = function toObject(message, options) {
49684
+ if (!options)
49685
+ options = {};
49686
+ var object = {};
49687
+ if (options.defaults) {
49688
+ object.replId = "";
49689
+ object.softTakedownId = "";
49690
+ }
49691
+ if (message.replId != null && message.hasOwnProperty("replId"))
49692
+ object.replId = message.replId;
49693
+ if (message.softTakedownId != null && message.hasOwnProperty("softTakedownId"))
49694
+ object.softTakedownId = message.softTakedownId;
49695
+ return object;
49696
+ };
49697
+
49698
+ /**
49699
+ * Converts this SoftTakedown to JSON.
49700
+ * @function toJSON
49701
+ * @memberof replit.goval.api.SoftTakedown
49702
+ * @instance
49703
+ * @returns {Object.<string,*>} JSON object
49704
+ */
49705
+ SoftTakedown.prototype.toJSON = function toJSON() {
49706
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
49707
+ };
49708
+
49709
+ return SoftTakedown;
49710
+ })();
49711
+
49712
+ api.GovalCommand = (function() {
49713
+
49714
+ /**
49715
+ * Properties of a GovalCommand.
49716
+ * @memberof replit.goval.api
49717
+ * @interface IGovalCommand
49718
+ * @property {replit.goval.api.repl.Metadata|replit.goval.api.repl.IMetadata|null} [updateMetadata] GovalCommand updateMetadata
49719
+ */
49720
+
49721
+ /**
49722
+ * Constructs a new GovalCommand.
49723
+ * @memberof replit.goval.api
49724
+ * @classdesc Represents a GovalCommand.
49725
+ * @constructor
49726
+ * @param {replit.goval.api.IGovalCommand=} [properties] Properties to set
49727
+ */
49728
+ function GovalCommand(properties) {
49729
+ if (properties)
49730
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
49731
+ if (properties[keys[i]] != null)
49732
+ this[keys[i]] = properties[keys[i]];
49733
+ }
49734
+
49735
+ /**
49736
+ * GovalCommand updateMetadata.
49737
+ * @member {replit.goval.api.repl.Metadata|null|undefined} updateMetadata
49738
+ * @memberof replit.goval.api.GovalCommand
49739
+ * @instance
49740
+ */
49741
+ GovalCommand.prototype.updateMetadata = null;
49742
+
49743
+ // OneOf field names bound to virtual getters and setters
49744
+ var $oneOfFields;
49745
+
49746
+ /**
49747
+ * GovalCommand command.
49748
+ * @member {"updateMetadata"|undefined} command
49749
+ * @memberof replit.goval.api.GovalCommand
49750
+ * @instance
49751
+ */
49752
+ Object.defineProperty(GovalCommand.prototype, "command", {
49753
+ get: $util.oneOfGetter($oneOfFields = ["updateMetadata"]),
49754
+ set: $util.oneOfSetter($oneOfFields)
49755
+ });
49756
+
49757
+ /**
49758
+ * Creates a new GovalCommand instance using the specified properties.
49759
+ * @function create
49760
+ * @memberof replit.goval.api.GovalCommand
49761
+ * @static
49762
+ * @param {replit.goval.api.IGovalCommand=} [properties] Properties to set
49763
+ * @returns {replit.goval.api.GovalCommand} GovalCommand instance
49764
+ */
49765
+ GovalCommand.create = function create(properties) {
49766
+ return GovalCommand.fromObject(properties);
49767
+ };
49768
+
49769
+ /**
49770
+ * Encodes the specified GovalCommand message. Does not implicitly {@link replit.goval.api.GovalCommand.verify|verify} messages.
49771
+ * @function encode
49772
+ * @memberof replit.goval.api.GovalCommand
49773
+ * @static
49774
+ * @param {replit.goval.api.GovalCommand} message GovalCommand message or plain object to encode
49775
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49776
+ * @returns {$protobuf.Writer} Writer
49777
+ */
49778
+ GovalCommand.encode = function encode(message, writer) {
49779
+ if (!writer)
49780
+ writer = $Writer.create();
49781
+ if (message.updateMetadata != null && Object.hasOwnProperty.call(message, "updateMetadata"))
49782
+ $root.replit.goval.api.repl.Metadata.encode(message.updateMetadata, writer.uint32(/* id 1, wireType 2 =*/10).fork()).ldelim();
49783
+ return writer;
49784
+ };
49785
+
49786
+ /**
49787
+ * Encodes the specified GovalCommand message, length delimited. Does not implicitly {@link replit.goval.api.GovalCommand.verify|verify} messages.
49788
+ * @function encodeDelimited
49789
+ * @memberof replit.goval.api.GovalCommand
49790
+ * @static
49791
+ * @param {replit.goval.api.GovalCommand} message GovalCommand message or plain object to encode
49792
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49793
+ * @returns {$protobuf.Writer} Writer
49794
+ */
49795
+ GovalCommand.encodeDelimited = function encodeDelimited(message, writer) {
49796
+ return this.encode(message, writer).ldelim();
49797
+ };
49798
+
49799
+ /**
49800
+ * Decodes a GovalCommand message from the specified reader or buffer.
49801
+ * @function decode
49802
+ * @memberof replit.goval.api.GovalCommand
49803
+ * @static
49804
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49805
+ * @param {number} [length] Message length if known beforehand
49806
+ * @returns {replit.goval.api.GovalCommand} GovalCommand
49807
+ * @throws {Error} If the payload is not a reader or valid buffer
49808
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49809
+ */
49810
+ GovalCommand.decode = function decode(reader, length) {
49811
+ if (!(reader instanceof $Reader))
49812
+ reader = $Reader.create(reader);
49813
+ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.GovalCommand();
49814
+ while (reader.pos < end) {
49815
+ var tag = reader.uint32();
49816
+ switch (tag >>> 3) {
49817
+ case 1:
49818
+ message.updateMetadata = $root.replit.goval.api.repl.Metadata.decode(reader, reader.uint32());
49819
+ break;
49820
+ default:
49821
+ reader.skipType(tag & 7);
49822
+ break;
49823
+ }
49824
+ }
49825
+ return message;
49826
+ };
49827
+
49828
+ /**
49829
+ * Decodes a GovalCommand message from the specified reader or buffer, length delimited.
49830
+ * @function decodeDelimited
49831
+ * @memberof replit.goval.api.GovalCommand
49832
+ * @static
49833
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
49834
+ * @returns {replit.goval.api.GovalCommand} GovalCommand
49835
+ * @throws {Error} If the payload is not a reader or valid buffer
49836
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
49837
+ */
49838
+ GovalCommand.decodeDelimited = function decodeDelimited(reader) {
49839
+ if (!(reader instanceof $Reader))
49840
+ reader = new $Reader(reader);
49841
+ return this.decode(reader, reader.uint32());
49842
+ };
49843
+
49844
+ /**
49845
+ * Verifies a GovalCommand message.
49846
+ * @function verify
49847
+ * @memberof replit.goval.api.GovalCommand
49848
+ * @static
49849
+ * @param {Object.<string,*>} message Plain object to verify
49850
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
49851
+ */
49852
+ GovalCommand.verify = function verify(message) {
49853
+ if (typeof message !== "object" || message === null)
49854
+ return "object expected";
49855
+ var properties = {};
49856
+ if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata")) {
49857
+ properties.command = 1;
49858
+ {
49859
+ var error = $root.replit.goval.api.repl.Metadata.verify(message.updateMetadata);
49860
+ if (error)
49861
+ return "updateMetadata." + error;
49862
+ }
49863
+ }
49864
+ return null;
49865
+ };
49866
+
49867
+ /**
49868
+ * Creates a GovalCommand message from a plain object. Also converts values to their respective internal types.
49869
+ * @function fromObject
49870
+ * @memberof replit.goval.api.GovalCommand
49871
+ * @static
49872
+ * @param {Object.<string,*>} object Plain object
49873
+ * @returns {replit.goval.api.GovalCommand} GovalCommand
49874
+ */
49875
+ GovalCommand.fromObject = function fromObject(object) {
49876
+ if (object instanceof $root.replit.goval.api.GovalCommand)
49877
+ return object;
49878
+ var message = new $root.replit.goval.api.GovalCommand();
49879
+ if (object.updateMetadata != null) {
49880
+ if (typeof object.updateMetadata !== "object")
49881
+ throw TypeError(".replit.goval.api.GovalCommand.updateMetadata: object expected");
49882
+ message.updateMetadata = $root.replit.goval.api.repl.Metadata.fromObject(object.updateMetadata);
49883
+ }
49884
+ return message;
49885
+ };
49886
+
49887
+ /**
49888
+ * Creates a plain object from a GovalCommand message. Also converts values to other types if specified.
49889
+ * @function toObject
49890
+ * @memberof replit.goval.api.GovalCommand
49891
+ * @static
49892
+ * @param {replit.goval.api.GovalCommand} message GovalCommand
49893
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
49894
+ * @returns {Object.<string,*>} Plain object
49895
+ */
49896
+ GovalCommand.toObject = function toObject(message, options) {
49897
+ if (!options)
49898
+ options = {};
49899
+ var object = {};
49900
+ if (message.updateMetadata != null && message.hasOwnProperty("updateMetadata")) {
49901
+ object.updateMetadata = $root.replit.goval.api.repl.Metadata.toObject(message.updateMetadata, options);
49902
+ if (options.oneofs)
49903
+ object.command = "updateMetadata";
49904
+ }
49905
+ return object;
49906
+ };
49907
+
49908
+ /**
49909
+ * Converts this GovalCommand to JSON.
49910
+ * @function toJSON
49911
+ * @memberof replit.goval.api.GovalCommand
49912
+ * @instance
49913
+ * @returns {Object.<string,*>} JSON object
49914
+ */
49915
+ GovalCommand.prototype.toJSON = function toJSON() {
49916
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
49917
+ };
49918
+
49919
+ return GovalCommand;
49920
+ })();
49921
+
49922
+ api.Restore = (function() {
49923
+
49924
+ /**
49925
+ * Properties of a Restore.
49926
+ * @memberof replit.goval.api
49927
+ * @interface IRestore
49928
+ * @property {string|null} [replId] Restore replId
49929
+ * @property {string|null} [restoreReplId] Restore restoreReplId
49930
+ */
49931
+
49932
+ /**
49933
+ * Constructs a new Restore.
49934
+ * @memberof replit.goval.api
49935
+ * @classdesc Represents a Restore.
49936
+ * @constructor
49937
+ * @param {replit.goval.api.IRestore=} [properties] Properties to set
49938
+ */
49939
+ function Restore(properties) {
49940
+ if (properties)
49941
+ for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)
49942
+ if (properties[keys[i]] != null)
49943
+ this[keys[i]] = properties[keys[i]];
49944
+ }
49945
+
49946
+ /**
49947
+ * Restore replId.
49948
+ * @member {string} replId
49949
+ * @memberof replit.goval.api.Restore
49950
+ * @instance
49951
+ */
49952
+ Restore.prototype.replId = "";
49953
+
49954
+ /**
49955
+ * Restore restoreReplId.
49956
+ * @member {string} restoreReplId
49957
+ * @memberof replit.goval.api.Restore
49958
+ * @instance
49959
+ */
49960
+ Restore.prototype.restoreReplId = "";
49961
+
49962
+ /**
49963
+ * Creates a new Restore instance using the specified properties.
49964
+ * @function create
49965
+ * @memberof replit.goval.api.Restore
49966
+ * @static
49967
+ * @param {replit.goval.api.IRestore=} [properties] Properties to set
49968
+ * @returns {replit.goval.api.Restore} Restore instance
49969
+ */
49970
+ Restore.create = function create(properties) {
49971
+ return Restore.fromObject(properties);
49972
+ };
49973
+
49974
+ /**
49975
+ * Encodes the specified Restore message. Does not implicitly {@link replit.goval.api.Restore.verify|verify} messages.
49976
+ * @function encode
49977
+ * @memberof replit.goval.api.Restore
49978
+ * @static
49979
+ * @param {replit.goval.api.Restore} message Restore message or plain object to encode
49980
+ * @param {$protobuf.Writer} [writer] Writer to encode to
49981
+ * @returns {$protobuf.Writer} Writer
49982
+ */
49983
+ Restore.encode = function encode(message, writer) {
49984
+ if (!writer)
49985
+ writer = $Writer.create();
49986
+ if (message.replId != null && Object.hasOwnProperty.call(message, "replId"))
49987
+ writer.uint32(/* id 1, wireType 2 =*/10).string(message.replId);
49988
+ if (message.restoreReplId != null && Object.hasOwnProperty.call(message, "restoreReplId"))
49989
+ writer.uint32(/* id 2, wireType 2 =*/18).string(message.restoreReplId);
49990
+ return writer;
49991
+ };
49992
+
49993
+ /**
49994
+ * Encodes the specified Restore message, length delimited. Does not implicitly {@link replit.goval.api.Restore.verify|verify} messages.
49995
+ * @function encodeDelimited
49996
+ * @memberof replit.goval.api.Restore
49997
+ * @static
49998
+ * @param {replit.goval.api.Restore} message Restore message or plain object to encode
49999
+ * @param {$protobuf.Writer} [writer] Writer to encode to
50000
+ * @returns {$protobuf.Writer} Writer
50001
+ */
50002
+ Restore.encodeDelimited = function encodeDelimited(message, writer) {
50003
+ return this.encode(message, writer).ldelim();
50004
+ };
50005
+
50006
+ /**
50007
+ * Decodes a Restore message from the specified reader or buffer.
50008
+ * @function decode
50009
+ * @memberof replit.goval.api.Restore
50010
+ * @static
50011
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
50012
+ * @param {number} [length] Message length if known beforehand
50013
+ * @returns {replit.goval.api.Restore} Restore
50014
+ * @throws {Error} If the payload is not a reader or valid buffer
50015
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
50016
+ */
50017
+ Restore.decode = function decode(reader, length) {
50018
+ if (!(reader instanceof $Reader))
50019
+ reader = $Reader.create(reader);
50020
+ var end = length === undefined ? reader.len : reader.pos + length, message = new $root.replit.goval.api.Restore();
50021
+ while (reader.pos < end) {
50022
+ var tag = reader.uint32();
50023
+ switch (tag >>> 3) {
50024
+ case 1:
50025
+ message.replId = reader.string();
50026
+ break;
50027
+ case 2:
50028
+ message.restoreReplId = reader.string();
50029
+ break;
50030
+ default:
50031
+ reader.skipType(tag & 7);
50032
+ break;
50033
+ }
50034
+ }
50035
+ return message;
50036
+ };
50037
+
50038
+ /**
50039
+ * Decodes a Restore message from the specified reader or buffer, length delimited.
50040
+ * @function decodeDelimited
50041
+ * @memberof replit.goval.api.Restore
50042
+ * @static
50043
+ * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
50044
+ * @returns {replit.goval.api.Restore} Restore
50045
+ * @throws {Error} If the payload is not a reader or valid buffer
50046
+ * @throws {$protobuf.util.ProtocolError} If required fields are missing
50047
+ */
50048
+ Restore.decodeDelimited = function decodeDelimited(reader) {
50049
+ if (!(reader instanceof $Reader))
50050
+ reader = new $Reader(reader);
50051
+ return this.decode(reader, reader.uint32());
50052
+ };
50053
+
50054
+ /**
50055
+ * Verifies a Restore message.
50056
+ * @function verify
50057
+ * @memberof replit.goval.api.Restore
50058
+ * @static
50059
+ * @param {Object.<string,*>} message Plain object to verify
50060
+ * @returns {string|null} `null` if valid, otherwise the reason why it is not
50061
+ */
50062
+ Restore.verify = function verify(message) {
50063
+ if (typeof message !== "object" || message === null)
50064
+ return "object expected";
50065
+ if (message.replId != null && message.hasOwnProperty("replId"))
50066
+ if (!$util.isString(message.replId))
50067
+ return "replId: string expected";
50068
+ if (message.restoreReplId != null && message.hasOwnProperty("restoreReplId"))
50069
+ if (!$util.isString(message.restoreReplId))
50070
+ return "restoreReplId: string expected";
50071
+ return null;
50072
+ };
50073
+
50074
+ /**
50075
+ * Creates a Restore message from a plain object. Also converts values to their respective internal types.
50076
+ * @function fromObject
50077
+ * @memberof replit.goval.api.Restore
50078
+ * @static
50079
+ * @param {Object.<string,*>} object Plain object
50080
+ * @returns {replit.goval.api.Restore} Restore
50081
+ */
50082
+ Restore.fromObject = function fromObject(object) {
50083
+ if (object instanceof $root.replit.goval.api.Restore)
50084
+ return object;
50085
+ var message = new $root.replit.goval.api.Restore();
50086
+ if (object.replId != null)
50087
+ message.replId = String(object.replId);
50088
+ if (object.restoreReplId != null)
50089
+ message.restoreReplId = String(object.restoreReplId);
50090
+ return message;
50091
+ };
50092
+
50093
+ /**
50094
+ * Creates a plain object from a Restore message. Also converts values to other types if specified.
50095
+ * @function toObject
50096
+ * @memberof replit.goval.api.Restore
50097
+ * @static
50098
+ * @param {replit.goval.api.Restore} message Restore
50099
+ * @param {$protobuf.IConversionOptions} [options] Conversion options
50100
+ * @returns {Object.<string,*>} Plain object
50101
+ */
50102
+ Restore.toObject = function toObject(message, options) {
50103
+ if (!options)
50104
+ options = {};
50105
+ var object = {};
50106
+ if (options.defaults) {
50107
+ object.replId = "";
50108
+ object.restoreReplId = "";
50109
+ }
50110
+ if (message.replId != null && message.hasOwnProperty("replId"))
50111
+ object.replId = message.replId;
50112
+ if (message.restoreReplId != null && message.hasOwnProperty("restoreReplId"))
50113
+ object.restoreReplId = message.restoreReplId;
50114
+ return object;
50115
+ };
50116
+
50117
+ /**
50118
+ * Converts this Restore to JSON.
50119
+ * @function toJSON
50120
+ * @memberof replit.goval.api.Restore
50121
+ * @instance
50122
+ * @returns {Object.<string,*>} JSON object
50123
+ */
50124
+ Restore.prototype.toJSON = function toJSON() {
50125
+ return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
50126
+ };
50127
+
50128
+ return Restore;
50129
+ })();
50130
+
48938
50131
  api.features = (function() {
48939
50132
 
48940
50133
  /**