@replit/protocol 0.4.20 → 0.4.23-dev.1

package/README.md

@@ -1,3 +1,57 @@
+# @replit/protocol
+
+JavaScript/TypeScript bindings for the Replit protocol.
+
+## Tree-Shakeable ESM Build
+
+This package now includes a tree-shakeable ES Module build alongside the existing CommonJS build.
+
+### Usage
+
+**Legacy namespace imports (default, fully backward compatible):**
+```typescript
+import { api } from '@replit/protocol';
+
+// Access types via namespace
+const target = api.DeploymentConfig.Target.VM;
+const token = api.token.ReplToken.create({ ... });
+```
+
+This is the default import and works in all environments without configuration changes.
+
+**Tree-shakeable ESM imports (recommended for new code in Next.js apps):**
+```typescript
+import { Persistence, ReplToken_WireFormat, Timestamp } from '@replit/protocol/esm';
+
+// Direct access to types
+const persistence: Persistence = Persistence.NONE;
+const format: ReplToken_WireFormat = ReplToken_WireFormat.PROTOBUF;
+```
+
+⚠️ **Note**: ESM imports require adding `@replit/protocol` to `transpilePackages` in `next.config.js`:
+```javascript
+transpilePackages: ['@replit/protocol', /* other packages */]
+```
+
+**CommonJS (Node.js require):**
+```typescript
+const { api } = require('@replit/protocol');
+const { Command } = api;
+```
+
+### Bundle Size Impact
+
+The ESM build enables ~80-90% bundle size reduction through tree-shaking:
+- **Full bundle**: ~848 KB
+- **Single type import**: ~23 KB (96% reduction)
+
+### Key Differences
+
+- **Legacy namespace** (`@replit/protocol`): Uses `api.token.ReplToken`, imports everything
+- **ESM direct imports** (`@replit/protocol/esm`): Uses `ReplToken_WireFormat`, tree-shakeable
+- ESM uses protobuf-ts with `toBinary()`/`fromBinary()` instead of `encode()`/`decode()`
+- ESM uses native `BigInt` instead of Long.js
+
 # Developing
 * Change goval/api/types.proto
 * In this directory:

package/dist/api/client.d.ts

@@ -0,0 +1,202 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Metadata } from "./repl/repl.js";
+import { ResourceLimits } from "./repl/repl.js";
+import { Repl } from "./repl/repl.js";
+/**
+ * TLSCertificate is a SSL/TLS certificate for a specific domain. This is used
+ * to transfer certificates between clusters when a repl is transferred so we do
+ * not need to request a new certificate in the new cluster.
+ *
+ * @generated from protobuf message replit.goval.api.TLSCertificate
+ */
+export interface TLSCertificate {
+    /**
+     * @generated from protobuf field: string domain = 1
+     */
+    domain: string;
+    /**
+     * @generated from protobuf field: bytes cert = 2
+     */
+    cert: Uint8Array;
+}
+/**
+ * ReplTransfer includes all the data needed to transfer a repl between
+ * clusters.
+ *
+ * @generated from protobuf message replit.goval.api.ReplTransfer
+ */
+export interface ReplTransfer {
+    /**
+     * @generated from protobuf field: replit.goval.api.repl.Repl repl = 1
+     */
+    repl?: Repl;
+    /**
+     * @generated from protobuf field: replit.goval.api.repl.ResourceLimits replLimits = 2
+     */
+    replLimits?: ResourceLimits;
+    /**
+     * @generated from protobuf field: replit.goval.api.repl.ResourceLimits userLimits = 3
+     */
+    userLimits?: ResourceLimits;
+    /**
+     * @generated from protobuf field: repeated string customDomains = 4
+     */
+    customDomains: string[];
+    /**
+     * @generated from protobuf field: repeated replit.goval.api.TLSCertificate certificates = 5
+     */
+    certificates: TLSCertificate[];
+    /**
+     * @generated from protobuf field: repeated string flags = 6
+     */
+    flags: string[];
+    /**
+     * @generated from protobuf field: replit.goval.api.repl.Metadata metadata = 7
+     */
+    metadata?: Metadata;
+}
+/**
+ * AllowReplRequest represents a request to allow a repl into a cluster.
+ *
+ * @generated from protobuf message replit.goval.api.AllowReplRequest
+ */
+export interface AllowReplRequest {
+    /**
+     * @generated from protobuf field: replit.goval.api.ReplTransfer replTransfer = 1
+     */
+    replTransfer?: ReplTransfer;
+}
+/**
+ * ClusterMetadata represents all the metadata Lore knows about a cluster. This
+ * includes all endpoints needed to communicate with the cluster.
+ *
+ * @generated from protobuf message replit.goval.api.ClusterMetadata
+ */
+export interface ClusterMetadata {
+    /**
+     * @generated from protobuf field: string id = 1
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: string conmanURL = 2
+     */
+    conmanURL: string;
+    /**
+     * @generated from protobuf field: string gurl = 3
+     */
+    gurl: string;
+    /**
+     * @generated from protobuf field: string proxy = 5
+     */
+    proxy: string;
+    /**
+     * @generated from protobuf field: string continent = 7
+     */
+    continent: string;
+}
+/**
+ * EvictReplRequest represents a request to evict a repl from a cluster.
+ * Includes the metadata about the repl that will be evicted and a token in
+ * case conman needs to forward this request to another instance.
+ *
+ * @generated from protobuf message replit.goval.api.EvictReplRequest
+ */
+export interface EvictReplRequest {
+    /**
+     * @generated from protobuf field: replit.goval.api.ClusterMetadata clusterMetadata = 1
+     */
+    clusterMetadata?: ClusterMetadata;
+    /**
+     * @generated from protobuf field: string token = 2
+     */
+    token: string;
+    /**
+     * User and slug are sent so that a repl route can be added even if the
+     * cluster doesn't have metadata for this repl.
+     *
+     * @generated from protobuf field: string user = 3
+     */
+    user: string;
+    /**
+     * @generated from protobuf field: string slug = 4
+     */
+    slug: string;
+}
+/**
+ * EvictReplResponse represents a response after evicting a repl from a cluster
+ * and includes metadata about the repl that was evicted.
+ *
+ * @generated from protobuf message replit.goval.api.EvictReplResponse
+ */
+export interface EvictReplResponse {
+    /**
+     * @generated from protobuf field: replit.goval.api.ReplTransfer replTransfer = 1
+     */
+    replTransfer?: ReplTransfer;
+}
+declare class TLSCertificate$Type extends MessageType<TLSCertificate> {
+    constructor();
+    create(value?: PartialMessage<TLSCertificate>): TLSCertificate;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: TLSCertificate): TLSCertificate;
+    internalBinaryWrite(message: TLSCertificate, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.TLSCertificate
+ */
+export declare const TLSCertificate: TLSCertificate$Type;
+declare class ReplTransfer$Type extends MessageType<ReplTransfer> {
+    constructor();
+    create(value?: PartialMessage<ReplTransfer>): ReplTransfer;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ReplTransfer): ReplTransfer;
+    internalBinaryWrite(message: ReplTransfer, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.ReplTransfer
+ */
+export declare const ReplTransfer: ReplTransfer$Type;
+declare class AllowReplRequest$Type extends MessageType<AllowReplRequest> {
+    constructor();
+    create(value?: PartialMessage<AllowReplRequest>): AllowReplRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AllowReplRequest): AllowReplRequest;
+    internalBinaryWrite(message: AllowReplRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.AllowReplRequest
+ */
+export declare const AllowReplRequest: AllowReplRequest$Type;
+declare class ClusterMetadata$Type extends MessageType<ClusterMetadata> {
+    constructor();
+    create(value?: PartialMessage<ClusterMetadata>): ClusterMetadata;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ClusterMetadata): ClusterMetadata;
+    internalBinaryWrite(message: ClusterMetadata, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.ClusterMetadata
+ */
+export declare const ClusterMetadata: ClusterMetadata$Type;
+declare class EvictReplRequest$Type extends MessageType<EvictReplRequest> {
+    constructor();
+    create(value?: PartialMessage<EvictReplRequest>): EvictReplRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvictReplRequest): EvictReplRequest;
+    internalBinaryWrite(message: EvictReplRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.EvictReplRequest
+ */
+export declare const EvictReplRequest: EvictReplRequest$Type;
+declare class EvictReplResponse$Type extends MessageType<EvictReplResponse> {
+    constructor();
+    create(value?: PartialMessage<EvictReplResponse>): EvictReplResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: EvictReplResponse): EvictReplResponse;
+    internalBinaryWrite(message: EvictReplResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message replit.goval.api.EvictReplResponse
+ */
+export declare const EvictReplResponse: EvictReplResponse$Type;
+export {};

package/dist/api/client.js

@@ -0,0 +1,394 @@
+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 { Metadata } from "./repl/repl.js";
+import { ResourceLimits } from "./repl/repl.js";
+import { Repl } from "./repl/repl.js";
+// @generated message type with reflection information, may provide speed optimized methods
+class TLSCertificate$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.TLSCertificate", [
+            { no: 1, name: "domain", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "cert", kind: "scalar", T: 12 /*ScalarType.BYTES*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.domain = "";
+        message.cert = new Uint8Array(0);
+        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 domain */ 1:
+                    message.domain = reader.string();
+                    break;
+                case /* bytes cert */ 2:
+                    message.cert = reader.bytes();
+                    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 domain = 1; */
+        if (message.domain !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.domain);
+        /* bytes cert = 2; */
+        if (message.cert.length)
+            writer.tag(2, WireType.LengthDelimited).bytes(message.cert);
+        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.TLSCertificate
+ */
+export const TLSCertificate = new TLSCertificate$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ReplTransfer$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.ReplTransfer", [
+            { no: 1, name: "repl", kind: "message", T: () => Repl },
+            { no: 2, name: "replLimits", kind: "message", T: () => ResourceLimits },
+            { no: 3, name: "userLimits", kind: "message", T: () => ResourceLimits },
+            { no: 4, name: "customDomains", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "certificates", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => TLSCertificate },
+            { no: 6, name: "flags", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "metadata", kind: "message", T: () => Metadata }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.customDomains = [];
+        message.certificates = [];
+        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 /* replit.goval.api.repl.Repl repl */ 1:
+                    message.repl = Repl.internalBinaryRead(reader, reader.uint32(), options, message.repl);
+                    break;
+                case /* replit.goval.api.repl.ResourceLimits replLimits */ 2:
+                    message.replLimits = ResourceLimits.internalBinaryRead(reader, reader.uint32(), options, message.replLimits);
+                    break;
+                case /* replit.goval.api.repl.ResourceLimits userLimits */ 3:
+                    message.userLimits = ResourceLimits.internalBinaryRead(reader, reader.uint32(), options, message.userLimits);
+                    break;
+                case /* repeated string customDomains */ 4:
+                    message.customDomains.push(reader.string());
+                    break;
+                case /* repeated replit.goval.api.TLSCertificate certificates */ 5:
+                    message.certificates.push(TLSCertificate.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated string flags */ 6:
+                    message.flags.push(reader.string());
+                    break;
+                case /* replit.goval.api.repl.Metadata metadata */ 7:
+                    message.metadata = Metadata.internalBinaryRead(reader, reader.uint32(), options, message.metadata);
+                    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.Repl repl = 1; */
+        if (message.repl)
+            Repl.internalBinaryWrite(message.repl, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.repl.ResourceLimits replLimits = 2; */
+        if (message.replLimits)
+            ResourceLimits.internalBinaryWrite(message.replLimits, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* replit.goval.api.repl.ResourceLimits userLimits = 3; */
+        if (message.userLimits)
+            ResourceLimits.internalBinaryWrite(message.userLimits, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string customDomains = 4; */
+        for (let i = 0; i < message.customDomains.length; i++)
+            writer.tag(4, WireType.LengthDelimited).string(message.customDomains[i]);
+        /* repeated replit.goval.api.TLSCertificate certificates = 5; */
+        for (let i = 0; i < message.certificates.length; i++)
+            TLSCertificate.internalBinaryWrite(message.certificates[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string flags = 6; */
+        for (let i = 0; i < message.flags.length; i++)
+            writer.tag(6, WireType.LengthDelimited).string(message.flags[i]);
+        /* replit.goval.api.repl.Metadata metadata = 7; */
+        if (message.metadata)
+            Metadata.internalBinaryWrite(message.metadata, writer.tag(7, 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.ReplTransfer
+ */
+export const ReplTransfer = new ReplTransfer$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AllowReplRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.AllowReplRequest", [
+            { no: 1, name: "replTransfer", kind: "message", T: () => ReplTransfer }
+        ]);
+    }
+    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.ReplTransfer replTransfer */ 1:
+                    message.replTransfer = ReplTransfer.internalBinaryRead(reader, reader.uint32(), options, message.replTransfer);
+                    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.ReplTransfer replTransfer = 1; */
+        if (message.replTransfer)
+            ReplTransfer.internalBinaryWrite(message.replTransfer, 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.AllowReplRequest
+ */
+export const AllowReplRequest = new AllowReplRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ClusterMetadata$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.ClusterMetadata", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "conmanURL", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "gurl", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 5, name: "proxy", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "continent", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.conmanURL = "";
+        message.gurl = "";
+        message.proxy = "";
+        message.continent = "";
+        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 id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* string conmanURL */ 2:
+                    message.conmanURL = reader.string();
+                    break;
+                case /* string gurl */ 3:
+                    message.gurl = reader.string();
+                    break;
+                case /* string proxy */ 5:
+                    message.proxy = reader.string();
+                    break;
+                case /* string continent */ 7:
+                    message.continent = 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 id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* string conmanURL = 2; */
+        if (message.conmanURL !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.conmanURL);
+        /* string gurl = 3; */
+        if (message.gurl !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.gurl);
+        /* string proxy = 5; */
+        if (message.proxy !== "")
+            writer.tag(5, WireType.LengthDelimited).string(message.proxy);
+        /* string continent = 7; */
+        if (message.continent !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.continent);
+        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.ClusterMetadata
+ */
+export const ClusterMetadata = new ClusterMetadata$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EvictReplRequest$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.EvictReplRequest", [
+            { no: 1, name: "clusterMetadata", kind: "message", T: () => ClusterMetadata },
+            { no: 2, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "user", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 4, name: "slug", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.token = "";
+        message.user = "";
+        message.slug = "";
+        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.ClusterMetadata clusterMetadata */ 1:
+                    message.clusterMetadata = ClusterMetadata.internalBinaryRead(reader, reader.uint32(), options, message.clusterMetadata);
+                    break;
+                case /* string token */ 2:
+                    message.token = reader.string();
+                    break;
+                case /* string user */ 3:
+                    message.user = reader.string();
+                    break;
+                case /* string slug */ 4:
+                    message.slug = 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) {
+        /* replit.goval.api.ClusterMetadata clusterMetadata = 1; */
+        if (message.clusterMetadata)
+            ClusterMetadata.internalBinaryWrite(message.clusterMetadata, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* string token = 2; */
+        if (message.token !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.token);
+        /* string user = 3; */
+        if (message.user !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.user);
+        /* string slug = 4; */
+        if (message.slug !== "")
+            writer.tag(4, WireType.LengthDelimited).string(message.slug);
+        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.EvictReplRequest
+ */
+export const EvictReplRequest = new EvictReplRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EvictReplResponse$Type extends MessageType {
+    constructor() {
+        super("replit.goval.api.EvictReplResponse", [
+            { no: 1, name: "replTransfer", kind: "message", T: () => ReplTransfer }
+        ]);
+    }
+    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.ReplTransfer replTransfer */ 1:
+                    message.replTransfer = ReplTransfer.internalBinaryRead(reader, reader.uint32(), options, message.replTransfer);
+                    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.ReplTransfer replTransfer = 1; */
+        if (message.replTransfer)
+            ReplTransfer.internalBinaryWrite(message.replTransfer, 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.EvictReplResponse
+ */
+export const EvictReplResponse = new EvictReplResponse$Type();