@replit/protocol 0.4.20 → 0.4.22

package/dist/api/lore/lore.js

@@ -0,0 +1,982 @@
+import { WireType } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { FieldMask } from "../../google/protobuf/field_mask.js";
+import { Metadata } from "../repl/repl.js";
+import { ReplLocation } from "./service.js";
+// @generated message type with reflection information, may provide speed optimized methods
+class LoreCommand$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.LoreCommand", [
+            { no: 1, name: "cluster_transfer", kind: "message", oneof: "command", T: () => ClusterTransfer },
+            { no: 2, name: "soft_takedown", kind: "message", oneof: "command", T: () => SoftTakedown },
+            { no: 6, name: "takedown", kind: "message", oneof: "command", T: () => Takedown },
+            { no: 3, name: "goval_command", kind: "message", oneof: "command", T: () => GovalCommand },
+            { no: 5, name: "multi_goval_command", kind: "message", oneof: "command", T: () => MultiGovalCommand },
+            { no: 4, name: "restore", kind: "message", oneof: "command", T: () => Restore }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.command = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* replit.goval.api.lore.ClusterTransfer cluster_transfer */ 1:
+                    message.command = {
+                        oneofKind: "clusterTransfer",
+                        clusterTransfer: ClusterTransfer.internalBinaryRead(reader, reader.uint32(), options, message.command.clusterTransfer)
+                    };
+                    break;
+                case /* replit.goval.api.lore.SoftTakedown soft_takedown */ 2:
+                    message.command = {
+                        oneofKind: "softTakedown",
+                        softTakedown: SoftTakedown.internalBinaryRead(reader, reader.uint32(), options, message.command.softTakedown)
+                    };
+                    break;
+                case /* replit.goval.api.lore.Takedown takedown */ 6:
+                    message.command = {
+                        oneofKind: "takedown",
+                        takedown: Takedown.internalBinaryRead(reader, reader.uint32(), options, message.command.takedown)
+                    };
+                    break;
+                case /* replit.goval.api.lore.GovalCommand goval_command */ 3:
+                    message.command = {
+                        oneofKind: "govalCommand",
+                        govalCommand: GovalCommand.internalBinaryRead(reader, reader.uint32(), options, message.command.govalCommand)
+                    };
+                    break;
+                case /* replit.goval.api.lore.MultiGovalCommand multi_goval_command */ 5:
+                    message.command = {
+                        oneofKind: "multiGovalCommand",
+                        multiGovalCommand: MultiGovalCommand.internalBinaryRead(reader, reader.uint32(), options, message.command.multiGovalCommand)
+                    };
+                    break;
+                case /* replit.goval.api.lore.Restore restore */ 4:
+                    message.command = {
+                        oneofKind: "restore",
+                        restore: Restore.internalBinaryRead(reader, reader.uint32(), options, message.command.restore)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* replit.goval.api.lore.ClusterTransfer cluster_transfer = 1; */
+        if (message.command.oneofKind === "clusterTransfer")
+            ClusterTransfer.internalBinaryWrite(message.command.clusterTransfer, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.SoftTakedown soft_takedown = 2; */
+        if (message.command.oneofKind === "softTakedown")
+            SoftTakedown.internalBinaryWrite(message.command.softTakedown, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.GovalCommand goval_command = 3; */
+        if (message.command.oneofKind === "govalCommand")
+            GovalCommand.internalBinaryWrite(message.command.govalCommand, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.Restore restore = 4; */
+        if (message.command.oneofKind === "restore")
+            Restore.internalBinaryWrite(message.command.restore, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.MultiGovalCommand multi_goval_command = 5; */
+        if (message.command.oneofKind === "multiGovalCommand")
+            MultiGovalCommand.internalBinaryWrite(message.command.multiGovalCommand, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.Takedown takedown = 6; */
+        if (message.command.oneofKind === "takedown")
+            Takedown.internalBinaryWrite(message.command.takedown, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.LoreCommand
+ */
+export const LoreCommand = new LoreCommand$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClusterTransfer$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.ClusterTransfer", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "user", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "new_cluster_id", kind: "scalar", oneof: "location", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "new_continent_id", kind: "scalar", oneof: "location", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "replLocation", kind: "message", T: () => ReplLocation },
+            { no: 4, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.user = "";
+        message.location = { oneofKind: undefined };
+        message.transferId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* string user */ 2:
+                    message.user = reader.string();
+                    break;
+                case /* string new_cluster_id = 3 [deprecated = true] */ 3:
+                    message.location = {
+                        oneofKind: "newClusterId",
+                        newClusterId: reader.string()
+                    };
+                    break;
+                case /* string new_continent_id = 5 [deprecated = true] */ 5:
+                    message.location = {
+                        oneofKind: "newContinentId",
+                        newContinentId: reader.string()
+                    };
+                    break;
+                case /* replit.goval.api.lore.ReplLocation replLocation */ 6:
+                    message.replLocation = ReplLocation.internalBinaryRead(reader, reader.uint32(), options, message.replLocation);
+                    break;
+                case /* string transfer_id */ 4:
+                    message.transferId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* string user = 2; */
+        if (message.user !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.user);
+        /* string new_cluster_id = 3 [deprecated = true]; */
+        if (message.location.oneofKind === "newClusterId")
+            writer.tag(3, WireType.LengthDelimited).string(message.location.newClusterId);
+        /* string transfer_id = 4; */
+        if (message.transferId !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.transferId);
+        /* string new_continent_id = 5 [deprecated = true]; */
+        if (message.location.oneofKind === "newContinentId")
+            writer.tag(5, WireType.LengthDelimited).string(message.location.newContinentId);
+        /* replit.goval.api.lore.ReplLocation replLocation = 6; */
+        if (message.replLocation)
+            ReplLocation.internalBinaryWrite(message.replLocation, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.ClusterTransfer
+ */
+export const ClusterTransfer = new ClusterTransfer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SoftTakedown$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.SoftTakedown", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "soft_takedown_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.softTakedownId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* string soft_takedown_id */ 2:
+                    message.softTakedownId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* string soft_takedown_id = 2; */
+        if (message.softTakedownId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.softTakedownId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.SoftTakedown
+ */
+export const SoftTakedown = new SoftTakedown$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Takedown$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.Takedown", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.Takedown
+ */
+export const Takedown = new Takedown$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class StartViktor$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.StartViktor", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.StartViktor
+ */
+export const StartViktor = new StartViktor$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GovalCommand$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GovalCommand", [
+            { no: 1, name: "update_metadata", kind: "message", oneof: "command", T: () => Metadata },
+            { no: 2, name: "partial_update_metadata", kind: "message", oneof: "command", T: () => PartialUpdateMetadata },
+            { no: 3, name: "kill_repl", kind: "message", oneof: "command", T: () => KillRepl },
+            { no: 4, name: "update_source_repl", kind: "message", oneof: "command", T: () => UpdateSourceRepl },
+            { no: 5, name: "update_repl_flags", kind: "message", oneof: "command", T: () => UpdateReplFlags },
+            { no: 6, name: "soft_takedown", kind: "message", oneof: "command", T: () => SoftTakedown },
+            { no: 7, name: "takedown", kind: "message", oneof: "command", T: () => Takedown },
+            { no: 9, name: "start_viktor", kind: "message", oneof: "command", T: () => StartViktor },
+            { no: 10, name: "add_token_to_repl_shield_allow_list", kind: "message", oneof: "command", T: () => AddTokenToReplShieldAllowList },
+            { no: 11, name: "revoke_user_repl_shield_tokens", kind: "message", oneof: "command", T: () => RevokeUserReplShieldTokens },
+            { no: 12, name: "set_replit_badge", kind: "message", oneof: "command", T: () => SetReplitBadge }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.command = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* replit.goval.api.repl.Metadata update_metadata */ 1:
+                    message.command = {
+                        oneofKind: "updateMetadata",
+                        updateMetadata: Metadata.internalBinaryRead(reader, reader.uint32(), options, message.command.updateMetadata)
+                    };
+                    break;
+                case /* replit.goval.api.lore.PartialUpdateMetadata partial_update_metadata */ 2:
+                    message.command = {
+                        oneofKind: "partialUpdateMetadata",
+                        partialUpdateMetadata: PartialUpdateMetadata.internalBinaryRead(reader, reader.uint32(), options, message.command.partialUpdateMetadata)
+                    };
+                    break;
+                case /* replit.goval.api.lore.KillRepl kill_repl */ 3:
+                    message.command = {
+                        oneofKind: "killRepl",
+                        killRepl: KillRepl.internalBinaryRead(reader, reader.uint32(), options, message.command.killRepl)
+                    };
+                    break;
+                case /* replit.goval.api.lore.UpdateSourceRepl update_source_repl */ 4:
+                    message.command = {
+                        oneofKind: "updateSourceRepl",
+                        updateSourceRepl: UpdateSourceRepl.internalBinaryRead(reader, reader.uint32(), options, message.command.updateSourceRepl)
+                    };
+                    break;
+                case /* replit.goval.api.lore.UpdateReplFlags update_repl_flags = 5 [deprecated = true] */ 5:
+                    message.command = {
+                        oneofKind: "updateReplFlags",
+                        updateReplFlags: UpdateReplFlags.internalBinaryRead(reader, reader.uint32(), options, message.command.updateReplFlags)
+                    };
+                    break;
+                case /* replit.goval.api.lore.SoftTakedown soft_takedown */ 6:
+                    message.command = {
+                        oneofKind: "softTakedown",
+                        softTakedown: SoftTakedown.internalBinaryRead(reader, reader.uint32(), options, message.command.softTakedown)
+                    };
+                    break;
+                case /* replit.goval.api.lore.Takedown takedown */ 7:
+                    message.command = {
+                        oneofKind: "takedown",
+                        takedown: Takedown.internalBinaryRead(reader, reader.uint32(), options, message.command.takedown)
+                    };
+                    break;
+                case /* replit.goval.api.lore.StartViktor start_viktor */ 9:
+                    message.command = {
+                        oneofKind: "startViktor",
+                        startViktor: StartViktor.internalBinaryRead(reader, reader.uint32(), options, message.command.startViktor)
+                    };
+                    break;
+                case /* replit.goval.api.lore.AddTokenToReplShieldAllowList add_token_to_repl_shield_allow_list */ 10:
+                    message.command = {
+                        oneofKind: "addTokenToReplShieldAllowList",
+                        addTokenToReplShieldAllowList: AddTokenToReplShieldAllowList.internalBinaryRead(reader, reader.uint32(), options, message.command.addTokenToReplShieldAllowList)
+                    };
+                    break;
+                case /* replit.goval.api.lore.RevokeUserReplShieldTokens revoke_user_repl_shield_tokens */ 11:
+                    message.command = {
+                        oneofKind: "revokeUserReplShieldTokens",
+                        revokeUserReplShieldTokens: RevokeUserReplShieldTokens.internalBinaryRead(reader, reader.uint32(), options, message.command.revokeUserReplShieldTokens)
+                    };
+                    break;
+                case /* replit.goval.api.lore.SetReplitBadge set_replit_badge */ 12:
+                    message.command = {
+                        oneofKind: "setReplitBadge",
+                        setReplitBadge: SetReplitBadge.internalBinaryRead(reader, reader.uint32(), options, message.command.setReplitBadge)
+                    };
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* replit.goval.api.repl.Metadata update_metadata = 1; */
+        if (message.command.oneofKind === "updateMetadata")
+            Metadata.internalBinaryWrite(message.command.updateMetadata, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.PartialUpdateMetadata partial_update_metadata = 2; */
+        if (message.command.oneofKind === "partialUpdateMetadata")
+            PartialUpdateMetadata.internalBinaryWrite(message.command.partialUpdateMetadata, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.KillRepl kill_repl = 3; */
+        if (message.command.oneofKind === "killRepl")
+            KillRepl.internalBinaryWrite(message.command.killRepl, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.UpdateSourceRepl update_source_repl = 4; */
+        if (message.command.oneofKind === "updateSourceRepl")
+            UpdateSourceRepl.internalBinaryWrite(message.command.updateSourceRepl, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.UpdateReplFlags update_repl_flags = 5 [deprecated = true]; */
+        if (message.command.oneofKind === "updateReplFlags")
+            UpdateReplFlags.internalBinaryWrite(message.command.updateReplFlags, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.SoftTakedown soft_takedown = 6; */
+        if (message.command.oneofKind === "softTakedown")
+            SoftTakedown.internalBinaryWrite(message.command.softTakedown, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.Takedown takedown = 7; */
+        if (message.command.oneofKind === "takedown")
+            Takedown.internalBinaryWrite(message.command.takedown, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.StartViktor start_viktor = 9; */
+        if (message.command.oneofKind === "startViktor")
+            StartViktor.internalBinaryWrite(message.command.startViktor, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.AddTokenToReplShieldAllowList add_token_to_repl_shield_allow_list = 10; */
+        if (message.command.oneofKind === "addTokenToReplShieldAllowList")
+            AddTokenToReplShieldAllowList.internalBinaryWrite(message.command.addTokenToReplShieldAllowList, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.RevokeUserReplShieldTokens revoke_user_repl_shield_tokens = 11; */
+        if (message.command.oneofKind === "revokeUserReplShieldTokens")
+            RevokeUserReplShieldTokens.internalBinaryWrite(message.command.revokeUserReplShieldTokens, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.SetReplitBadge set_replit_badge = 12; */
+        if (message.command.oneofKind === "setReplitBadge")
+            SetReplitBadge.internalBinaryWrite(message.command.setReplitBadge, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.GovalCommand
+ */
+export const GovalCommand = new GovalCommand$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PartialUpdateMetadata$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.PartialUpdateMetadata", [
+            { no: 1, name: "field_mask", kind: "message", T: () => FieldMask },
+            { no: 2, name: "update_metadata", kind: "message", T: () => Metadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* google.protobuf.FieldMask field_mask */ 1:
+                    message.fieldMask = FieldMask.internalBinaryRead(reader, reader.uint32(), options, message.fieldMask);
+                    break;
+                case /* replit.goval.api.repl.Metadata update_metadata */ 2:
+                    message.updateMetadata = Metadata.internalBinaryRead(reader, reader.uint32(), options, message.updateMetadata);
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* google.protobuf.FieldMask field_mask = 1; */
+        if (message.fieldMask)
+            FieldMask.internalBinaryWrite(message.fieldMask, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.repl.Metadata update_metadata = 2; */
+        if (message.updateMetadata)
+            Metadata.internalBinaryWrite(message.updateMetadata, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.PartialUpdateMetadata
+ */
+export const PartialUpdateMetadata = new PartialUpdateMetadata$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MultiGovalCommand$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.MultiGovalCommand", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "goval_commands", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GovalCommand }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.govalCommands = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* repeated replit.goval.api.lore.GovalCommand goval_commands */ 2:
+                    message.govalCommands.push(GovalCommand.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* repeated replit.goval.api.lore.GovalCommand goval_commands = 2; */
+        for (let i = 0; i < message.govalCommands.length; i++)
+            GovalCommand.internalBinaryWrite(message.govalCommands[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.MultiGovalCommand
+ */
+export const MultiGovalCommand = new MultiGovalCommand$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class KillRepl$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.KillRepl", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.KillRepl
+ */
+export const KillRepl = new KillRepl$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Restore$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.Restore", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.Restore
+ */
+export const Restore = new Restore$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateSourceRepl$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.UpdateSourceRepl", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "source_repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.sourceReplId = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* string source_repl_id */ 2:
+                    message.sourceReplId = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* string source_repl_id = 2; */
+        if (message.sourceReplId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.sourceReplId);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.UpdateSourceRepl
+ */
+export const UpdateSourceRepl = new UpdateSourceRepl$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class UpdateReplFlags$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.UpdateReplFlags", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "flags", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.flags = [];
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* repeated string flags */ 2:
+                    message.flags.push(reader.string());
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* repeated string flags = 2; */
+        for (let i = 0; i < message.flags.length; i++)
+            writer.tag(2, WireType.LengthDelimited).string(message.flags[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.UpdateReplFlags
+ */
+export const UpdateReplFlags = new UpdateReplFlags$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AddTokenToReplShieldAllowList$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.AddTokenToReplShieldAllowList", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.token = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* string token */ 2:
+                    message.token = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* string token = 2; */
+        if (message.token !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.token);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.AddTokenToReplShieldAllowList
+ */
+export const AddTokenToReplShieldAllowList = new AddTokenToReplShieldAllowList$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class RevokeUserReplShieldTokens$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.RevokeUserReplShieldTokens", [
+            { no: 1, name: "user_id", kind: "scalar", T: 13 /*ScalarType.UINT32*/ },
+            { no: 2, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.userId = 0;
+        message.token = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* uint32 user_id */ 1:
+                    message.userId = reader.uint32();
+                    break;
+                case /* string token */ 2:
+                    message.token = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* uint32 user_id = 1; */
+        if (message.userId !== 0)
+            writer.tag(1, WireType.Varint).uint32(message.userId);
+        /* string token = 2; */
+        if (message.token !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.token);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.RevokeUserReplShieldTokens
+ */
+export const RevokeUserReplShieldTokens = new RevokeUserReplShieldTokens$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class SetReplitBadge$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.SetReplitBadge", [
+            { no: 1, name: "repl_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "enable", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "referral_code", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.replId = "";
+        message.enable = false;
+        message.referralCode = "";
+        if (value !== undefined)
+            reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string repl_id */ 1:
+                    message.replId = reader.string();
+                    break;
+                case /* bool enable */ 2:
+                    message.enable = reader.bool();
+                    break;
+                case /* string referral_code */ 3:
+                    message.referralCode = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string repl_id = 1; */
+        if (message.replId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.replId);
+        /* bool enable = 2; */
+        if (message.enable !== false)
+            writer.tag(2, WireType.Varint).bool(message.enable);
+        /* string referral_code = 3; */
+        if (message.referralCode !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.referralCode);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.lore.SetReplitBadge
+ */
+export const SetReplitBadge = new SetReplitBadge$Type();