@replit/protocol 0.6.0 → 0.6.1

package/dist/api/lore/service.js

@@ -203,7 +203,10 @@ class Cluster$Type extends MessageType {
             { no: 20, name: "openint_server_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 21, name: "bff_url", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 22, name: "templ_rpc_target", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 23, name: "slack_adapter_rpc_target", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 23, name: "slack_adapter_rpc_target", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 24, name: "operational", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 25, name: "add_to_cluster_selector", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 26, name: "growth_rpc_target", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
     create(value) {
@@ -230,6 +233,9 @@ class Cluster$Type extends MessageType {
         message.bffUrl = "";
         message.templRpcTarget = "";
         message.slackAdapterRpcTarget = "";
+        message.operational = false;
+        message.addToClusterSelector = false;
+        message.growthRpcTarget = "";
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -305,6 +311,15 @@ class Cluster$Type extends MessageType {
                 case /* string slack_adapter_rpc_target */ 23:
                     message.slackAdapterRpcTarget = reader.string();
                     break;
+                case /* bool operational */ 24:
+                    message.operational = reader.bool();
+                    break;
+                case /* bool add_to_cluster_selector */ 25:
+                    message.addToClusterSelector = reader.bool();
+                    break;
+                case /* string growth_rpc_target */ 26:
+                    message.growthRpcTarget = reader.string();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -383,6 +398,15 @@ class Cluster$Type extends MessageType {
         /* string slack_adapter_rpc_target = 23; */
         if (message.slackAdapterRpcTarget !== "")
             writer.tag(23, WireType.LengthDelimited).string(message.slackAdapterRpcTarget);
+        /* bool operational = 24; */
+        if (message.operational !== false)
+            writer.tag(24, WireType.Varint).bool(message.operational);
+        /* bool add_to_cluster_selector = 25; */
+        if (message.addToClusterSelector !== false)
+            writer.tag(25, WireType.Varint).bool(message.addToClusterSelector);
+        /* string growth_rpc_target = 26; */
+        if (message.growthRpcTarget !== "")
+            writer.tag(26, WireType.LengthDelimited).string(message.growthRpcTarget);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -3204,13 +3228,15 @@ class TransferResourceGroupRequest$Type extends MessageType {
     constructor() {
         super("replit.goval.api.lore.TransferResourceGroupRequest", [
             { no: 1, name: "resource_group_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 2, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "run_without_queue", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
         ]);
     }
     create(value) {
         const message = globalThis.Object.create((this.messagePrototype));
         message.resourceGroupId = "";
         message.orgId = "";
+        message.runWithoutQueue = false;
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -3226,6 +3252,9 @@ class TransferResourceGroupRequest$Type extends MessageType {
                 case /* string org_id */ 2:
                     message.orgId = reader.string();
                     break;
+                case /* bool run_without_queue */ 3:
+                    message.runWithoutQueue = reader.bool();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -3244,6 +3273,9 @@ class TransferResourceGroupRequest$Type extends MessageType {
         /* string org_id = 2; */
         if (message.orgId !== "")
             writer.tag(2, WireType.LengthDelimited).string(message.orgId);
+        /* bool run_without_queue = 3; */
+        if (message.runWithoutQueue !== false)
+            writer.tag(3, WireType.Varint).bool(message.runWithoutQueue);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -3258,12 +3290,16 @@ export const TransferResourceGroupRequest = new TransferResourceGroupRequest$Typ
 class TransferResourceGroupResponse$Type extends MessageType {
     constructor() {
         super("replit.goval.api.lore.TransferResourceGroupResponse", [
-            { no: 1, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "queued", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 3, name: "queue_status", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
     create(value) {
         const message = globalThis.Object.create((this.messagePrototype));
         message.transferId = "";
+        message.queued = false;
+        message.queueStatus = "";
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -3276,6 +3312,12 @@ class TransferResourceGroupResponse$Type extends MessageType {
                 case /* string transfer_id */ 1:
                     message.transferId = reader.string();
                     break;
+                case /* bool queued */ 2:
+                    message.queued = reader.bool();
+                    break;
+                case /* string queue_status */ 3:
+                    message.queueStatus = reader.string();
+                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -3291,6 +3333,12 @@ class TransferResourceGroupResponse$Type extends MessageType {
         /* string transfer_id = 1; */
         if (message.transferId !== "")
             writer.tag(1, WireType.LengthDelimited).string(message.transferId);
+        /* bool queued = 2; */
+        if (message.queued !== false)
+            writer.tag(2, WireType.Varint).bool(message.queued);
+        /* string queue_status = 3; */
+        if (message.queueStatus !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.queueStatus);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -3302,6 +3350,1016 @@ class TransferResourceGroupResponse$Type extends MessageType {
  */
 export const TransferResourceGroupResponse = new TransferResourceGroupResponse$Type();
 // @generated message type with reflection information, may provide speed optimized methods
+class TransferQueueEntry$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.TransferQueueEntry", [
+            { no: 1, name: "resource_group_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "status", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "enqueued_at", kind: "message", T: () => Timestamp },
+            { no: 6, name: "admitted_at", kind: "message", T: () => Timestamp },
+            { no: 7, name: "started_at", kind: "message", T: () => Timestamp },
+            { no: 8, name: "finished_at", kind: "message", T: () => Timestamp },
+            { no: 9, name: "next_attempt_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.resourceGroupId = "";
+        message.orgId = "";
+        message.transferId = "";
+        message.status = "";
+        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 resource_group_id */ 1:
+                    message.resourceGroupId = reader.string();
+                    break;
+                case /* string org_id */ 2:
+                    message.orgId = reader.string();
+                    break;
+                case /* string transfer_id */ 3:
+                    message.transferId = reader.string();
+                    break;
+                case /* string status */ 4:
+                    message.status = reader.string();
+                    break;
+                case /* google.protobuf.Timestamp enqueued_at */ 5:
+                    message.enqueuedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.enqueuedAt);
+                    break;
+                case /* google.protobuf.Timestamp admitted_at */ 6:
+                    message.admittedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.admittedAt);
+                    break;
+                case /* google.protobuf.Timestamp started_at */ 7:
+                    message.startedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startedAt);
+                    break;
+                case /* google.protobuf.Timestamp finished_at */ 8:
+                    message.finishedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.finishedAt);
+                    break;
+                case /* google.protobuf.Timestamp next_attempt_at */ 9:
+                    message.nextAttemptAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.nextAttemptAt);
+                    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 resource_group_id = 1; */
+        if (message.resourceGroupId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.resourceGroupId);
+        /* string org_id = 2; */
+        if (message.orgId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.orgId);
+        /* string transfer_id = 3; */
+        if (message.transferId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.transferId);
+        /* string status = 4; */
+        if (message.status !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.status);
+        /* google.protobuf.Timestamp enqueued_at = 5; */
+        if (message.enqueuedAt)
+            Timestamp.internalBinaryWrite(message.enqueuedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp admitted_at = 6; */
+        if (message.admittedAt)
+            Timestamp.internalBinaryWrite(message.admittedAt, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp started_at = 7; */
+        if (message.startedAt)
+            Timestamp.internalBinaryWrite(message.startedAt, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp finished_at = 8; */
+        if (message.finishedAt)
+            Timestamp.internalBinaryWrite(message.finishedAt, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp next_attempt_at = 9; */
+        if (message.nextAttemptAt)
+            Timestamp.internalBinaryWrite(message.nextAttemptAt, writer.tag(9, 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.TransferQueueEntry
+ */
+export const TransferQueueEntry = new TransferQueueEntry$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferQueueLease$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.TransferQueueLease", [
+            { no: 1, name: "holder_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "epoch", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "expires_at", kind: "message", T: () => Timestamp }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.holderId = "";
+        message.epoch = 0n;
+        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 holder_id */ 1:
+                    message.holderId = reader.string();
+                    break;
+                case /* int64 epoch */ 2:
+                    message.epoch = reader.int64().toBigInt();
+                    break;
+                case /* google.protobuf.Timestamp expires_at */ 3:
+                    message.expiresAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.expiresAt);
+                    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 holder_id = 1; */
+        if (message.holderId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.holderId);
+        /* int64 epoch = 2; */
+        if (message.epoch !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.epoch);
+        /* google.protobuf.Timestamp expires_at = 3; */
+        if (message.expiresAt)
+            Timestamp.internalBinaryWrite(message.expiresAt, writer.tag(3, 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.TransferQueueLease
+ */
+export const TransferQueueLease = new TransferQueueLease$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferQueueSettings$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.TransferQueueSettings", [
+            { no: 1, name: "paused", kind: "scalar", T: 8 /*ScalarType.BOOL*/ },
+            { no: 2, name: "max_in_flight", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 3, name: "error", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.paused = false;
+        message.maxInFlight = 0;
+        message.error = "";
+        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 /* bool paused */ 1:
+                    message.paused = reader.bool();
+                    break;
+                case /* int32 max_in_flight */ 2:
+                    message.maxInFlight = reader.int32();
+                    break;
+                case /* string error */ 3:
+                    message.error = 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) {
+        /* bool paused = 1; */
+        if (message.paused !== false)
+            writer.tag(1, WireType.Varint).bool(message.paused);
+        /* int32 max_in_flight = 2; */
+        if (message.maxInFlight !== 0)
+            writer.tag(2, WireType.Varint).int32(message.maxInFlight);
+        /* string error = 3; */
+        if (message.error !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.error);
+        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.TransferQueueSettings
+ */
+export const TransferQueueSettings = new TransferQueueSettings$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferQueueStatusRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferQueueStatusRequest", []);
+    }
+    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) {
+                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) {
+        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.GetTransferQueueStatusRequest
+ */
+export const GetTransferQueueStatusRequest = new GetTransferQueueStatusRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferQueueStatusResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferQueueStatusResponse", [
+            { no: 1, name: "pending", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "starting", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "running", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 4, name: "deferred", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 5, name: "oldest_pending_age", kind: "message", T: () => Duration },
+            { no: 6, name: "next_deferred_attempt_at", kind: "message", T: () => Timestamp },
+            { no: 7, name: "lease", kind: "message", T: () => TransferQueueLease },
+            { no: 8, name: "settings", kind: "message", T: () => TransferQueueSettings }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.pending = 0n;
+        message.starting = 0n;
+        message.running = 0n;
+        message.deferred = 0n;
+        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 /* int64 pending */ 1:
+                    message.pending = reader.int64().toBigInt();
+                    break;
+                case /* int64 starting */ 2:
+                    message.starting = reader.int64().toBigInt();
+                    break;
+                case /* int64 running */ 3:
+                    message.running = reader.int64().toBigInt();
+                    break;
+                case /* int64 deferred */ 4:
+                    message.deferred = reader.int64().toBigInt();
+                    break;
+                case /* google.protobuf.Duration oldest_pending_age */ 5:
+                    message.oldestPendingAge = Duration.internalBinaryRead(reader, reader.uint32(), options, message.oldestPendingAge);
+                    break;
+                case /* google.protobuf.Timestamp next_deferred_attempt_at */ 6:
+                    message.nextDeferredAttemptAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.nextDeferredAttemptAt);
+                    break;
+                case /* replit.goval.api.lore.TransferQueueLease lease */ 7:
+                    message.lease = TransferQueueLease.internalBinaryRead(reader, reader.uint32(), options, message.lease);
+                    break;
+                case /* replit.goval.api.lore.TransferQueueSettings settings */ 8:
+                    message.settings = TransferQueueSettings.internalBinaryRead(reader, reader.uint32(), options, message.settings);
+                    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) {
+        /* int64 pending = 1; */
+        if (message.pending !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.pending);
+        /* int64 starting = 2; */
+        if (message.starting !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.starting);
+        /* int64 running = 3; */
+        if (message.running !== 0n)
+            writer.tag(3, WireType.Varint).int64(message.running);
+        /* int64 deferred = 4; */
+        if (message.deferred !== 0n)
+            writer.tag(4, WireType.Varint).int64(message.deferred);
+        /* google.protobuf.Duration oldest_pending_age = 5; */
+        if (message.oldestPendingAge)
+            Duration.internalBinaryWrite(message.oldestPendingAge, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* google.protobuf.Timestamp next_deferred_attempt_at = 6; */
+        if (message.nextDeferredAttemptAt)
+            Timestamp.internalBinaryWrite(message.nextDeferredAttemptAt, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.TransferQueueLease lease = 7; */
+        if (message.lease)
+            TransferQueueLease.internalBinaryWrite(message.lease, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.TransferQueueSettings settings = 8; */
+        if (message.settings)
+            TransferQueueSettings.internalBinaryWrite(message.settings, writer.tag(8, 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.GetTransferQueueStatusResponse
+ */
+export const GetTransferQueueStatusResponse = new GetTransferQueueStatusResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListTransferQueueRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.ListTransferQueueRequest", [
+            { no: 1, name: "statuses", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "limit", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
+            { no: 4, name: "page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.statuses = [];
+        message.orgId = "";
+        message.limit = 0;
+        message.pageToken = "";
+        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 /* repeated string statuses */ 1:
+                    message.statuses.push(reader.string());
+                    break;
+                case /* string org_id */ 2:
+                    message.orgId = reader.string();
+                    break;
+                case /* int32 limit */ 3:
+                    message.limit = reader.int32();
+                    break;
+                case /* string page_token */ 4:
+                    message.pageToken = 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) {
+        /* repeated string statuses = 1; */
+        for (let i = 0; i < message.statuses.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.statuses[i]);
+        /* string org_id = 2; */
+        if (message.orgId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.orgId);
+        /* int32 limit = 3; */
+        if (message.limit !== 0)
+            writer.tag(3, WireType.Varint).int32(message.limit);
+        /* string page_token = 4; */
+        if (message.pageToken !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.pageToken);
+        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.ListTransferQueueRequest
+ */
+export const ListTransferQueueRequest = new ListTransferQueueRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListTransferQueueResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.ListTransferQueueResponse", [
+            { no: 1, name: "entries", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TransferQueueEntry },
+            { no: 2, name: "next_page_token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.entries = [];
+        message.nextPageToken = "";
+        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 /* repeated replit.goval.api.lore.TransferQueueEntry entries */ 1:
+                    message.entries.push(TransferQueueEntry.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* string next_page_token */ 2:
+                    message.nextPageToken = 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) {
+        /* repeated replit.goval.api.lore.TransferQueueEntry entries = 1; */
+        for (let i = 0; i < message.entries.length; i++)
+            TransferQueueEntry.internalBinaryWrite(message.entries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string next_page_token = 2; */
+        if (message.nextPageToken !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.nextPageToken);
+        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.ListTransferQueueResponse
+ */
+export const ListTransferQueueResponse = new ListTransferQueueResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class TransferLock$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.TransferLock", [
+            { no: 1, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "cell_name", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "workflow_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "workflow_status", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "workflow_error", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 6, name: "queue_status", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.transferId = "";
+        message.cellName = "";
+        message.workflowId = "";
+        message.workflowStatus = "";
+        message.workflowError = "";
+        message.queueStatus = "";
+        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 transfer_id */ 1:
+                    message.transferId = reader.string();
+                    break;
+                case /* string cell_name */ 2:
+                    message.cellName = reader.string();
+                    break;
+                case /* string workflow_id */ 3:
+                    message.workflowId = reader.string();
+                    break;
+                case /* string workflow_status */ 4:
+                    message.workflowStatus = reader.string();
+                    break;
+                case /* string workflow_error */ 5:
+                    message.workflowError = reader.string();
+                    break;
+                case /* string queue_status */ 6:
+                    message.queueStatus = 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 transfer_id = 1; */
+        if (message.transferId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.transferId);
+        /* string cell_name = 2; */
+        if (message.cellName !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.cellName);
+        /* string workflow_id = 3; */
+        if (message.workflowId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.workflowId);
+        /* string workflow_status = 4; */
+        if (message.workflowStatus !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.workflowStatus);
+        /* string workflow_error = 5; */
+        if (message.workflowError !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.workflowError);
+        /* string queue_status = 6; */
+        if (message.queueStatus !== "")
+            writer.tag(6, WireType.LengthDelimited).string(message.queueStatus);
+        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.TransferLock
+ */
+export const TransferLock = new TransferLock$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferQueueEntryRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferQueueEntryRequest", [
+            { no: 1, name: "resource_group_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.resourceGroupId = "";
+        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 resource_group_id */ 1:
+                    message.resourceGroupId = 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 resource_group_id = 1; */
+        if (message.resourceGroupId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.resourceGroupId);
+        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.GetTransferQueueEntryRequest
+ */
+export const GetTransferQueueEntryRequest = new GetTransferQueueEntryRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferQueueEntryResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferQueueEntryResponse", [
+            { no: 1, name: "entry", kind: "message", T: () => TransferQueueEntry },
+            { no: 2, name: "lock", kind: "message", T: () => TransferLock }
+        ]);
+    }
+    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 /* replit.goval.api.lore.TransferQueueEntry entry */ 1:
+                    message.entry = TransferQueueEntry.internalBinaryRead(reader, reader.uint32(), options, message.entry);
+                    break;
+                case /* replit.goval.api.lore.TransferLock lock */ 2:
+                    message.lock = TransferLock.internalBinaryRead(reader, reader.uint32(), options, message.lock);
+                    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.TransferQueueEntry entry = 1; */
+        if (message.entry)
+            TransferQueueEntry.internalBinaryWrite(message.entry, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.lore.TransferLock lock = 2; */
+        if (message.lock)
+            TransferLock.internalBinaryWrite(message.lock, 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.GetTransferQueueEntryResponse
+ */
+export const GetTransferQueueEntryResponse = new GetTransferQueueEntryResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CancelQueuedTransferRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.CancelQueuedTransferRequest", [
+            { no: 1, name: "resource_group_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "org_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.resourceGroupId = "";
+        message.orgId = "";
+        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 resource_group_id */ 1:
+                    message.resourceGroupId = reader.string();
+                    break;
+                case /* string org_id */ 2:
+                    message.orgId = 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 resource_group_id = 1; */
+        if (message.resourceGroupId !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.resourceGroupId);
+        /* string org_id = 2; */
+        if (message.orgId !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.orgId);
+        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.CancelQueuedTransferRequest
+ */
+export const CancelQueuedTransferRequest = new CancelQueuedTransferRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class CancelQueuedTransferResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.CancelQueuedTransferResponse", [
+            { no: 1, name: "entry", kind: "message", T: () => TransferQueueEntry }
+        ]);
+    }
+    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 /* replit.goval.api.lore.TransferQueueEntry entry */ 1:
+                    message.entry = TransferQueueEntry.internalBinaryRead(reader, reader.uint32(), options, message.entry);
+                    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.TransferQueueEntry entry = 1; */
+        if (message.entry)
+            TransferQueueEntry.internalBinaryWrite(message.entry, writer.tag(1, 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.CancelQueuedTransferResponse
+ */
+export const CancelQueuedTransferResponse = new CancelQueuedTransferResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferLockRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferLockRequest", [
+            { no: 1, name: "resource_group_id", kind: "scalar", oneof: "target", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "org_id", kind: "scalar", oneof: "target", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.target = { 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 /* string resource_group_id */ 1:
+                    message.target = {
+                        oneofKind: "resourceGroupId",
+                        resourceGroupId: reader.string()
+                    };
+                    break;
+                case /* string org_id */ 2:
+                    message.target = {
+                        oneofKind: "orgId",
+                        orgId: 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 resource_group_id = 1; */
+        if (message.target.oneofKind === "resourceGroupId")
+            writer.tag(1, WireType.LengthDelimited).string(message.target.resourceGroupId);
+        /* string org_id = 2; */
+        if (message.target.oneofKind === "orgId")
+            writer.tag(2, WireType.LengthDelimited).string(message.target.orgId);
+        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.GetTransferLockRequest
+ */
+export const GetTransferLockRequest = new GetTransferLockRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class GetTransferLockResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.GetTransferLockResponse", [
+            { no: 1, name: "lock", kind: "message", T: () => TransferLock }
+        ]);
+    }
+    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 /* replit.goval.api.lore.TransferLock lock */ 1:
+                    message.lock = TransferLock.internalBinaryRead(reader, reader.uint32(), options, message.lock);
+                    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.TransferLock lock = 1; */
+        if (message.lock)
+            TransferLock.internalBinaryWrite(message.lock, writer.tag(1, 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.GetTransferLockResponse
+ */
+export const GetTransferLockResponse = new GetTransferLockResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReleaseTransferLockRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.ReleaseTransferLockRequest", [
+            { no: 1, name: "resource_group_id", kind: "scalar", oneof: "target", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "org_id", kind: "scalar", oneof: "target", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "transfer_id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "force", kind: "scalar", T: 8 /*ScalarType.BOOL*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.target = { oneofKind: undefined };
+        message.transferId = "";
+        message.force = false;
+        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 resource_group_id */ 1:
+                    message.target = {
+                        oneofKind: "resourceGroupId",
+                        resourceGroupId: reader.string()
+                    };
+                    break;
+                case /* string org_id */ 2:
+                    message.target = {
+                        oneofKind: "orgId",
+                        orgId: reader.string()
+                    };
+                    break;
+                case /* string transfer_id */ 3:
+                    message.transferId = reader.string();
+                    break;
+                case /* bool force */ 4:
+                    message.force = reader.bool();
+                    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 resource_group_id = 1; */
+        if (message.target.oneofKind === "resourceGroupId")
+            writer.tag(1, WireType.LengthDelimited).string(message.target.resourceGroupId);
+        /* string org_id = 2; */
+        if (message.target.oneofKind === "orgId")
+            writer.tag(2, WireType.LengthDelimited).string(message.target.orgId);
+        /* string transfer_id = 3; */
+        if (message.transferId !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.transferId);
+        /* bool force = 4; */
+        if (message.force !== false)
+            writer.tag(4, WireType.Varint).bool(message.force);
+        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.ReleaseTransferLockRequest
+ */
+export const ReleaseTransferLockRequest = new ReleaseTransferLockRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReleaseTransferLockResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.lore.ReleaseTransferLockResponse", [
+            { no: 1, name: "lock", kind: "message", T: () => TransferLock }
+        ]);
+    }
+    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 /* replit.goval.api.lore.TransferLock lock */ 1:
+                    message.lock = TransferLock.internalBinaryRead(reader, reader.uint32(), options, message.lock);
+                    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.TransferLock lock = 1; */
+        if (message.lock)
+            TransferLock.internalBinaryWrite(message.lock, writer.tag(1, 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.ReleaseTransferLockResponse
+ */
+export const ReleaseTransferLockResponse = new ReleaseTransferLockResponse$Type();
+// @generated message type with reflection information, may provide speed optimized methods
 class TransferReplsRequest$Type extends MessageType {
     constructor() {
         super("replit.goval.api.lore.TransferReplsRequest", [
@@ -5477,6 +6535,12 @@ export const Lore = new ServiceType("replit.goval.api.lore.Lore", [
     { name: "GetReplConnectionInfo", options: {}, I: GetReplConnectionInfoRequest, O: GetReplConnectionInfoResponse },
     { name: "GetTransferStatus", options: {}, I: GetTransferStatusRequest, O: GetTransferStatusResponse },
     { name: "TransferResourceGroup", options: {}, I: TransferResourceGroupRequest, O: TransferResourceGroupResponse },
+    { name: "GetTransferQueueStatus", options: {}, I: GetTransferQueueStatusRequest, O: GetTransferQueueStatusResponse },
+    { name: "ListTransferQueue", options: {}, I: ListTransferQueueRequest, O: ListTransferQueueResponse },
+    { name: "GetTransferQueueEntry", options: {}, I: GetTransferQueueEntryRequest, O: GetTransferQueueEntryResponse },
+    { name: "CancelQueuedTransfer", options: {}, I: CancelQueuedTransferRequest, O: CancelQueuedTransferResponse },
+    { name: "GetTransferLock", options: {}, I: GetTransferLockRequest, O: GetTransferLockResponse },
+    { name: "ReleaseTransferLock", options: {}, I: ReleaseTransferLockRequest, O: ReleaseTransferLockResponse },
     { name: "TransferRepls", options: {}, I: TransferReplsRequest, O: TransferReplsResponse },
     { name: "TransferUser", options: {}, I: TransferUserRequest, O: TransferUserResponse },
     { name: "TakedownRepl", options: {}, I: TakedownReplRequest, O: TakedownReplResponse },