@rivetkit/engine-envoy-protocol 0.0.0-0-0-0-preview-guard-stops.9d82529

package/dist/index.d.ts

@@ -0,0 +1,1238 @@
+import * as bare from '@rivetkit/bare-ts';
+
+type i64 = bigint;
+type u16 = number;
+type u32 = number;
+type u64 = bigint;
+type Id = string;
+declare function readId(bc: bare.ByteCursor): Id;
+declare function writeId(bc: bare.ByteCursor, x: Id): void;
+type Json = string;
+declare function readJson(bc: bare.ByteCursor): Json;
+declare function writeJson(bc: bare.ByteCursor, x: Json): void;
+type GatewayId = ArrayBuffer;
+declare function readGatewayId(bc: bare.ByteCursor): GatewayId;
+declare function writeGatewayId(bc: bare.ByteCursor, x: GatewayId): void;
+type RequestId = ArrayBuffer;
+declare function readRequestId(bc: bare.ByteCursor): RequestId;
+declare function writeRequestId(bc: bare.ByteCursor, x: RequestId): void;
+type MessageIndex = u16;
+declare function readMessageIndex(bc: bare.ByteCursor): MessageIndex;
+declare function writeMessageIndex(bc: bare.ByteCursor, x: MessageIndex): void;
+/**
+ * Basic types
+ */
+type KvKey = ArrayBuffer;
+declare function readKvKey(bc: bare.ByteCursor): KvKey;
+declare function writeKvKey(bc: bare.ByteCursor, x: KvKey): void;
+type KvValue = ArrayBuffer;
+declare function readKvValue(bc: bare.ByteCursor): KvValue;
+declare function writeKvValue(bc: bare.ByteCursor, x: KvValue): void;
+type KvMetadata = {
+    readonly version: ArrayBuffer;
+    readonly updateTs: i64;
+};
+declare function readKvMetadata(bc: bare.ByteCursor): KvMetadata;
+declare function writeKvMetadata(bc: bare.ByteCursor, x: KvMetadata): void;
+/**
+ * Query types
+ */
+type KvListAllQuery = null;
+type KvListRangeQuery = {
+    readonly start: KvKey;
+    readonly end: KvKey;
+    readonly exclusive: boolean;
+};
+declare function readKvListRangeQuery(bc: bare.ByteCursor): KvListRangeQuery;
+declare function writeKvListRangeQuery(bc: bare.ByteCursor, x: KvListRangeQuery): void;
+type KvListPrefixQuery = {
+    readonly key: KvKey;
+};
+declare function readKvListPrefixQuery(bc: bare.ByteCursor): KvListPrefixQuery;
+declare function writeKvListPrefixQuery(bc: bare.ByteCursor, x: KvListPrefixQuery): void;
+type KvListQuery = {
+    readonly tag: "KvListAllQuery";
+    readonly val: KvListAllQuery;
+} | {
+    readonly tag: "KvListRangeQuery";
+    readonly val: KvListRangeQuery;
+} | {
+    readonly tag: "KvListPrefixQuery";
+    readonly val: KvListPrefixQuery;
+};
+declare function readKvListQuery(bc: bare.ByteCursor): KvListQuery;
+declare function writeKvListQuery(bc: bare.ByteCursor, x: KvListQuery): void;
+/**
+ * Request types
+ */
+type KvGetRequest = {
+    readonly keys: readonly KvKey[];
+};
+declare function readKvGetRequest(bc: bare.ByteCursor): KvGetRequest;
+declare function writeKvGetRequest(bc: bare.ByteCursor, x: KvGetRequest): void;
+type KvListRequest = {
+    readonly query: KvListQuery;
+    readonly reverse: boolean | null;
+    readonly limit: u64 | null;
+};
+declare function readKvListRequest(bc: bare.ByteCursor): KvListRequest;
+declare function writeKvListRequest(bc: bare.ByteCursor, x: KvListRequest): void;
+type KvPutRequest = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+};
+declare function readKvPutRequest(bc: bare.ByteCursor): KvPutRequest;
+declare function writeKvPutRequest(bc: bare.ByteCursor, x: KvPutRequest): void;
+type KvDeleteRequest = {
+    readonly keys: readonly KvKey[];
+};
+declare function readKvDeleteRequest(bc: bare.ByteCursor): KvDeleteRequest;
+declare function writeKvDeleteRequest(bc: bare.ByteCursor, x: KvDeleteRequest): void;
+type KvDeleteRangeRequest = {
+    readonly start: KvKey;
+    readonly end: KvKey;
+};
+declare function readKvDeleteRangeRequest(bc: bare.ByteCursor): KvDeleteRangeRequest;
+declare function writeKvDeleteRangeRequest(bc: bare.ByteCursor, x: KvDeleteRangeRequest): void;
+type KvDropRequest = null;
+/**
+ * Response types
+ */
+type KvErrorResponse = {
+    readonly message: string;
+};
+declare function readKvErrorResponse(bc: bare.ByteCursor): KvErrorResponse;
+declare function writeKvErrorResponse(bc: bare.ByteCursor, x: KvErrorResponse): void;
+type KvGetResponse = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+    readonly metadata: readonly KvMetadata[];
+};
+declare function readKvGetResponse(bc: bare.ByteCursor): KvGetResponse;
+declare function writeKvGetResponse(bc: bare.ByteCursor, x: KvGetResponse): void;
+type KvListResponse = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+    readonly metadata: readonly KvMetadata[];
+};
+declare function readKvListResponse(bc: bare.ByteCursor): KvListResponse;
+declare function writeKvListResponse(bc: bare.ByteCursor, x: KvListResponse): void;
+type KvPutResponse = null;
+type KvDeleteResponse = null;
+type KvDropResponse = null;
+/**
+ * Request/Response unions
+ */
+type KvRequestData = {
+    readonly tag: "KvGetRequest";
+    readonly val: KvGetRequest;
+} | {
+    readonly tag: "KvListRequest";
+    readonly val: KvListRequest;
+} | {
+    readonly tag: "KvPutRequest";
+    readonly val: KvPutRequest;
+} | {
+    readonly tag: "KvDeleteRequest";
+    readonly val: KvDeleteRequest;
+} | {
+    readonly tag: "KvDeleteRangeRequest";
+    readonly val: KvDeleteRangeRequest;
+} | {
+    readonly tag: "KvDropRequest";
+    readonly val: KvDropRequest;
+};
+declare function readKvRequestData(bc: bare.ByteCursor): KvRequestData;
+declare function writeKvRequestData(bc: bare.ByteCursor, x: KvRequestData): void;
+type KvResponseData = {
+    readonly tag: "KvErrorResponse";
+    readonly val: KvErrorResponse;
+} | {
+    readonly tag: "KvGetResponse";
+    readonly val: KvGetResponse;
+} | {
+    readonly tag: "KvListResponse";
+    readonly val: KvListResponse;
+} | {
+    readonly tag: "KvPutResponse";
+    readonly val: KvPutResponse;
+} | {
+    readonly tag: "KvDeleteResponse";
+    readonly val: KvDeleteResponse;
+} | {
+    readonly tag: "KvDropResponse";
+    readonly val: KvDropResponse;
+};
+declare function readKvResponseData(bc: bare.ByteCursor): KvResponseData;
+declare function writeKvResponseData(bc: bare.ByteCursor, x: KvResponseData): void;
+type SqlitePgno = u32;
+declare function readSqlitePgno(bc: bare.ByteCursor): SqlitePgno;
+declare function writeSqlitePgno(bc: bare.ByteCursor, x: SqlitePgno): void;
+type SqliteGeneration = u64;
+declare function readSqliteGeneration(bc: bare.ByteCursor): SqliteGeneration;
+declare function writeSqliteGeneration(bc: bare.ByteCursor, x: SqliteGeneration): void;
+type SqlitePageBytes = ArrayBuffer;
+declare function readSqlitePageBytes(bc: bare.ByteCursor): SqlitePageBytes;
+declare function writeSqlitePageBytes(bc: bare.ByteCursor, x: SqlitePageBytes): void;
+type SqliteDirtyPage = {
+    readonly pgno: SqlitePgno;
+    readonly bytes: SqlitePageBytes;
+};
+declare function readSqliteDirtyPage(bc: bare.ByteCursor): SqliteDirtyPage;
+declare function writeSqliteDirtyPage(bc: bare.ByteCursor, x: SqliteDirtyPage): void;
+type SqliteFetchedPage = {
+    readonly pgno: SqlitePgno;
+    readonly bytes: SqlitePageBytes | null;
+};
+declare function readSqliteFetchedPage(bc: bare.ByteCursor): SqliteFetchedPage;
+declare function writeSqliteFetchedPage(bc: bare.ByteCursor, x: SqliteFetchedPage): void;
+type SqliteGetPagesRequest = {
+    readonly actorId: Id;
+    readonly pgnos: readonly SqlitePgno[];
+    readonly expectedGeneration: u64 | null;
+    readonly expectedHeadTxid: u64 | null;
+};
+declare function readSqliteGetPagesRequest(bc: bare.ByteCursor): SqliteGetPagesRequest;
+declare function writeSqliteGetPagesRequest(bc: bare.ByteCursor, x: SqliteGetPagesRequest): void;
+type SqliteGetPagesOk = {
+    readonly pages: readonly SqliteFetchedPage[];
+    readonly headTxid: u64 | null;
+};
+declare function readSqliteGetPagesOk(bc: bare.ByteCursor): SqliteGetPagesOk;
+declare function writeSqliteGetPagesOk(bc: bare.ByteCursor, x: SqliteGetPagesOk): void;
+type SqliteErrorResponse = {
+    readonly group: string;
+    readonly code: string;
+    readonly message: string;
+};
+declare function readSqliteErrorResponse(bc: bare.ByteCursor): SqliteErrorResponse;
+declare function writeSqliteErrorResponse(bc: bare.ByteCursor, x: SqliteErrorResponse): void;
+type SqliteGetPagesResponse = {
+    readonly tag: "SqliteGetPagesOk";
+    readonly val: SqliteGetPagesOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteGetPagesResponse(bc: bare.ByteCursor): SqliteGetPagesResponse;
+declare function writeSqliteGetPagesResponse(bc: bare.ByteCursor, x: SqliteGetPagesResponse): void;
+type SqliteCommitRequest = {
+    readonly actorId: Id;
+    readonly dirtyPages: readonly SqliteDirtyPage[];
+    readonly dbSizePages: u32;
+    readonly nowMs: i64;
+    readonly expectedGeneration: u64 | null;
+    readonly expectedHeadTxid: u64 | null;
+};
+declare function readSqliteCommitRequest(bc: bare.ByteCursor): SqliteCommitRequest;
+declare function writeSqliteCommitRequest(bc: bare.ByteCursor, x: SqliteCommitRequest): void;
+type SqliteCommitOk = {
+    readonly headTxid: u64 | null;
+};
+declare function readSqliteCommitOk(bc: bare.ByteCursor): SqliteCommitOk;
+declare function writeSqliteCommitOk(bc: bare.ByteCursor, x: SqliteCommitOk): void;
+type SqliteCommitResponse = {
+    readonly tag: "SqliteCommitOk";
+    readonly val: SqliteCommitOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteCommitResponse(bc: bare.ByteCursor): SqliteCommitResponse;
+declare function writeSqliteCommitResponse(bc: bare.ByteCursor, x: SqliteCommitResponse): void;
+/**
+ * Staged commit. A commit too large for one transaction is written as a sequence of shard-aligned
+ * segments and then made visible by a single finalize. Nothing staged is readable until finalize:
+ * no PIDX row, no COMMIT row, no head advance, so an abandoned stage is indistinguishable from no
+ * commit at all. The single-shot SqliteCommitRequest above stays the path for small commits.
+ */
+type SqliteCommitStageBeginRequest = {
+    readonly actorId: Id;
+    readonly expectedGeneration: u64 | null;
+    /**
+     * Fences before any bytes are staged, so an actor that lost its generation does not pay for a
+     * full payload before finding out.
+     */
+    readonly expectedHeadTxid: u64 | null;
+};
+declare function readSqliteCommitStageBeginRequest(bc: bare.ByteCursor): SqliteCommitStageBeginRequest;
+declare function writeSqliteCommitStageBeginRequest(bc: bare.ByteCursor, x: SqliteCommitStageBeginRequest): void;
+type SqliteCommitStageBeginOk = {
+    /**
+     * The engine allocates the txid (head + 1). Actor exclusivity makes that safe without an
+     * allocator.
+     */
+    readonly txid: u64;
+};
+declare function readSqliteCommitStageBeginOk(bc: bare.ByteCursor): SqliteCommitStageBeginOk;
+declare function writeSqliteCommitStageBeginOk(bc: bare.ByteCursor, x: SqliteCommitStageBeginOk): void;
+type SqliteCommitStageBeginResponse = {
+    readonly tag: "SqliteCommitStageBeginOk";
+    readonly val: SqliteCommitStageBeginOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteCommitStageBeginResponse(bc: bare.ByteCursor): SqliteCommitStageBeginResponse;
+declare function writeSqliteCommitStageBeginResponse(bc: bare.ByteCursor, x: SqliteCommitStageBeginResponse): void;
+type SqliteCommitStageSegmentRequest = {
+    readonly actorId: Id;
+    readonly expectedGeneration: u64 | null;
+    readonly txid: u64;
+    /**
+     * Shard-aligned and strictly ascending across a commit's segments. The engine rejects a
+     * misaligned or out-of-order value rather than trusting the client to have produced it
+     * correctly: a shard split across two segments could be folded from one of them and written as
+     * a shard image missing the other's newer pages.
+     */
+    readonly firstPgno: u32;
+    readonly dirtyPages: readonly SqliteDirtyPage[];
+};
+declare function readSqliteCommitStageSegmentRequest(bc: bare.ByteCursor): SqliteCommitStageSegmentRequest;
+declare function writeSqliteCommitStageSegmentRequest(bc: bare.ByteCursor, x: SqliteCommitStageSegmentRequest): void;
+type SqliteCommitStageSegmentOk = {
+    readonly stagedBytes: u64;
+};
+declare function readSqliteCommitStageSegmentOk(bc: bare.ByteCursor): SqliteCommitStageSegmentOk;
+declare function writeSqliteCommitStageSegmentOk(bc: bare.ByteCursor, x: SqliteCommitStageSegmentOk): void;
+type SqliteCommitStageSegmentResponse = {
+    readonly tag: "SqliteCommitStageSegmentOk";
+    readonly val: SqliteCommitStageSegmentOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteCommitStageSegmentResponse(bc: bare.ByteCursor): SqliteCommitStageSegmentResponse;
+declare function writeSqliteCommitStageSegmentResponse(bc: bare.ByteCursor, x: SqliteCommitStageSegmentResponse): void;
+type SqliteCommitFinalizeRequest = {
+    readonly actorId: Id;
+    readonly expectedGeneration: u64 | null;
+    /**
+     * The txid begin allocated. It is the head fence as well as the identity: finalize requires it to
+     * still be `head + 1`, so a separate expectedHeadTxid would only ever restate `txid - 1`.
+     */
+    readonly txid: u64;
+    readonly newDbSizePages: u32;
+    readonly nowMs: i64;
+    /**
+     * Exactly what the client believes it staged. Finalize verifies each one exists, so a client
+     * that lost a stage reply and finalized anyway is rejected instead of publishing a commit with
+     * a hole in it. Dirty page numbers are not carried here: the engine derives them from the
+     * staged segments' own page indexes.
+     */
+    readonly segmentFirstPgnos: Uint32Array;
+};
+declare function readSqliteCommitFinalizeRequest(bc: bare.ByteCursor): SqliteCommitFinalizeRequest;
+declare function writeSqliteCommitFinalizeRequest(bc: bare.ByteCursor, x: SqliteCommitFinalizeRequest): void;
+type SqliteCommitFinalizeOk = {
+    readonly headTxid: u64 | null;
+};
+declare function readSqliteCommitFinalizeOk(bc: bare.ByteCursor): SqliteCommitFinalizeOk;
+declare function writeSqliteCommitFinalizeOk(bc: bare.ByteCursor, x: SqliteCommitFinalizeOk): void;
+type SqliteCommitFinalizeResponse = {
+    readonly tag: "SqliteCommitFinalizeOk";
+    readonly val: SqliteCommitFinalizeOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteCommitFinalizeResponse(bc: bare.ByteCursor): SqliteCommitFinalizeResponse;
+declare function writeSqliteCommitFinalizeResponse(bc: bare.ByteCursor, x: SqliteCommitFinalizeResponse): void;
+type SqliteValueNull = null;
+type SqliteValueInteger = {
+    readonly value: i64;
+};
+declare function readSqliteValueInteger(bc: bare.ByteCursor): SqliteValueInteger;
+declare function writeSqliteValueInteger(bc: bare.ByteCursor, x: SqliteValueInteger): void;
+type SqliteValueFloat = {
+    readonly value: ArrayBuffer;
+};
+declare function readSqliteValueFloat(bc: bare.ByteCursor): SqliteValueFloat;
+declare function writeSqliteValueFloat(bc: bare.ByteCursor, x: SqliteValueFloat): void;
+type SqliteValueText = {
+    readonly value: string;
+};
+declare function readSqliteValueText(bc: bare.ByteCursor): SqliteValueText;
+declare function writeSqliteValueText(bc: bare.ByteCursor, x: SqliteValueText): void;
+type SqliteValueBlob = {
+    readonly value: ArrayBuffer;
+};
+declare function readSqliteValueBlob(bc: bare.ByteCursor): SqliteValueBlob;
+declare function writeSqliteValueBlob(bc: bare.ByteCursor, x: SqliteValueBlob): void;
+type SqliteBindParam = {
+    readonly tag: "SqliteValueNull";
+    readonly val: SqliteValueNull;
+} | {
+    readonly tag: "SqliteValueInteger";
+    readonly val: SqliteValueInteger;
+} | {
+    readonly tag: "SqliteValueFloat";
+    readonly val: SqliteValueFloat;
+} | {
+    readonly tag: "SqliteValueText";
+    readonly val: SqliteValueText;
+} | {
+    readonly tag: "SqliteValueBlob";
+    readonly val: SqliteValueBlob;
+};
+declare function readSqliteBindParam(bc: bare.ByteCursor): SqliteBindParam;
+declare function writeSqliteBindParam(bc: bare.ByteCursor, x: SqliteBindParam): void;
+type SqliteColumnValue = {
+    readonly tag: "SqliteValueNull";
+    readonly val: SqliteValueNull;
+} | {
+    readonly tag: "SqliteValueInteger";
+    readonly val: SqliteValueInteger;
+} | {
+    readonly tag: "SqliteValueFloat";
+    readonly val: SqliteValueFloat;
+} | {
+    readonly tag: "SqliteValueText";
+    readonly val: SqliteValueText;
+} | {
+    readonly tag: "SqliteValueBlob";
+    readonly val: SqliteValueBlob;
+};
+declare function readSqliteColumnValue(bc: bare.ByteCursor): SqliteColumnValue;
+declare function writeSqliteColumnValue(bc: bare.ByteCursor, x: SqliteColumnValue): void;
+type SqliteQueryResult = {
+    readonly columns: readonly string[];
+    readonly rows: readonly (readonly SqliteColumnValue[])[];
+};
+declare function readSqliteQueryResult(bc: bare.ByteCursor): SqliteQueryResult;
+declare function writeSqliteQueryResult(bc: bare.ByteCursor, x: SqliteQueryResult): void;
+type SqliteExecuteResult = {
+    readonly columns: readonly string[];
+    readonly rows: readonly (readonly SqliteColumnValue[])[];
+    readonly changes: i64;
+    readonly lastInsertRowId: i64 | null;
+};
+declare function readSqliteExecuteResult(bc: bare.ByteCursor): SqliteExecuteResult;
+declare function writeSqliteExecuteResult(bc: bare.ByteCursor, x: SqliteExecuteResult): void;
+type SqliteExecRequest = {
+    readonly namespaceId: Id;
+    readonly actorId: Id;
+    readonly generation: SqliteGeneration;
+    readonly sql: string;
+};
+declare function readSqliteExecRequest(bc: bare.ByteCursor): SqliteExecRequest;
+declare function writeSqliteExecRequest(bc: bare.ByteCursor, x: SqliteExecRequest): void;
+type SqliteExecuteRequest = {
+    readonly namespaceId: Id;
+    readonly actorId: Id;
+    readonly generation: SqliteGeneration;
+    readonly sql: string;
+    readonly params: readonly SqliteBindParam[] | null;
+};
+declare function readSqliteExecuteRequest(bc: bare.ByteCursor): SqliteExecuteRequest;
+declare function writeSqliteExecuteRequest(bc: bare.ByteCursor, x: SqliteExecuteRequest): void;
+type SqliteBatchStatement = {
+    readonly sql: string;
+    readonly params: readonly SqliteBindParam[] | null;
+};
+declare function readSqliteBatchStatement(bc: bare.ByteCursor): SqliteBatchStatement;
+declare function writeSqliteBatchStatement(bc: bare.ByteCursor, x: SqliteBatchStatement): void;
+type SqliteExecuteBatchRequest = {
+    readonly namespaceId: Id;
+    readonly actorId: Id;
+    readonly generation: SqliteGeneration;
+    readonly statements: readonly SqliteBatchStatement[];
+};
+declare function readSqliteExecuteBatchRequest(bc: bare.ByteCursor): SqliteExecuteBatchRequest;
+declare function writeSqliteExecuteBatchRequest(bc: bare.ByteCursor, x: SqliteExecuteBatchRequest): void;
+type SqliteExecOk = {
+    readonly result: SqliteQueryResult;
+};
+declare function readSqliteExecOk(bc: bare.ByteCursor): SqliteExecOk;
+declare function writeSqliteExecOk(bc: bare.ByteCursor, x: SqliteExecOk): void;
+type SqliteExecuteOk = {
+    readonly result: SqliteExecuteResult;
+};
+declare function readSqliteExecuteOk(bc: bare.ByteCursor): SqliteExecuteOk;
+declare function writeSqliteExecuteOk(bc: bare.ByteCursor, x: SqliteExecuteOk): void;
+type SqliteExecuteBatchOk = {
+    readonly results: readonly SqliteExecuteResult[];
+};
+declare function readSqliteExecuteBatchOk(bc: bare.ByteCursor): SqliteExecuteBatchOk;
+declare function writeSqliteExecuteBatchOk(bc: bare.ByteCursor, x: SqliteExecuteBatchOk): void;
+type SqliteExecResponse = {
+    readonly tag: "SqliteExecOk";
+    readonly val: SqliteExecOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteExecResponse(bc: bare.ByteCursor): SqliteExecResponse;
+declare function writeSqliteExecResponse(bc: bare.ByteCursor, x: SqliteExecResponse): void;
+type SqliteExecuteResponse = {
+    readonly tag: "SqliteExecuteOk";
+    readonly val: SqliteExecuteOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteExecuteResponse(bc: bare.ByteCursor): SqliteExecuteResponse;
+declare function writeSqliteExecuteResponse(bc: bare.ByteCursor, x: SqliteExecuteResponse): void;
+type SqliteExecuteBatchResponse = {
+    readonly tag: "SqliteExecuteBatchOk";
+    readonly val: SqliteExecuteBatchOk;
+} | {
+    readonly tag: "SqliteErrorResponse";
+    readonly val: SqliteErrorResponse;
+};
+declare function readSqliteExecuteBatchResponse(bc: bare.ByteCursor): SqliteExecuteBatchResponse;
+declare function writeSqliteExecuteBatchResponse(bc: bare.ByteCursor, x: SqliteExecuteBatchResponse): void;
+/**
+ * Core
+ */
+declare enum StopCode {
+    Ok = "Ok",
+    Error = "Error"
+}
+declare function readStopCode(bc: bare.ByteCursor): StopCode;
+declare function writeStopCode(bc: bare.ByteCursor, x: StopCode): void;
+type ActorName = {
+    readonly metadata: Json;
+};
+declare function readActorName(bc: bare.ByteCursor): ActorName;
+declare function writeActorName(bc: bare.ByteCursor, x: ActorName): void;
+type ActorConfig = {
+    readonly name: string;
+    readonly key: string | null;
+    readonly createTs: i64;
+    readonly input: ArrayBuffer | null;
+};
+declare function readActorConfig(bc: bare.ByteCursor): ActorConfig;
+declare function writeActorConfig(bc: bare.ByteCursor, x: ActorConfig): void;
+type ActorCheckpoint = {
+    readonly actorId: Id;
+    readonly generation: u32;
+    readonly index: i64;
+};
+declare function readActorCheckpoint(bc: bare.ByteCursor): ActorCheckpoint;
+declare function writeActorCheckpoint(bc: bare.ByteCursor, x: ActorCheckpoint): void;
+/**
+ * Intent
+ */
+type ActorIntentSleep = null;
+type ActorIntentStop = null;
+type ActorIntent = {
+    readonly tag: "ActorIntentSleep";
+    readonly val: ActorIntentSleep;
+} | {
+    readonly tag: "ActorIntentStop";
+    readonly val: ActorIntentStop;
+};
+declare function readActorIntent(bc: bare.ByteCursor): ActorIntent;
+declare function writeActorIntent(bc: bare.ByteCursor, x: ActorIntent): void;
+/**
+ * State
+ */
+type ActorStateRunning = null;
+type ActorStateStopped = {
+    readonly code: StopCode;
+    readonly message: string | null;
+};
+declare function readActorStateStopped(bc: bare.ByteCursor): ActorStateStopped;
+declare function writeActorStateStopped(bc: bare.ByteCursor, x: ActorStateStopped): void;
+type ActorState = {
+    readonly tag: "ActorStateRunning";
+    readonly val: ActorStateRunning;
+} | {
+    readonly tag: "ActorStateStopped";
+    readonly val: ActorStateStopped;
+};
+declare function readActorState(bc: bare.ByteCursor): ActorState;
+declare function writeActorState(bc: bare.ByteCursor, x: ActorState): void;
+/**
+ * MARK: Events
+ */
+type EventActorIntent = {
+    readonly intent: ActorIntent;
+};
+declare function readEventActorIntent(bc: bare.ByteCursor): EventActorIntent;
+declare function writeEventActorIntent(bc: bare.ByteCursor, x: EventActorIntent): void;
+type EventActorStateUpdate = {
+    readonly state: ActorState;
+};
+declare function readEventActorStateUpdate(bc: bare.ByteCursor): EventActorStateUpdate;
+declare function writeEventActorStateUpdate(bc: bare.ByteCursor, x: EventActorStateUpdate): void;
+type EventActorSetAlarm = {
+    readonly alarmTs: i64 | null;
+};
+declare function readEventActorSetAlarm(bc: bare.ByteCursor): EventActorSetAlarm;
+declare function writeEventActorSetAlarm(bc: bare.ByteCursor, x: EventActorSetAlarm): void;
+type Event = {
+    readonly tag: "EventActorIntent";
+    readonly val: EventActorIntent;
+} | {
+    readonly tag: "EventActorStateUpdate";
+    readonly val: EventActorStateUpdate;
+} | {
+    readonly tag: "EventActorSetAlarm";
+    readonly val: EventActorSetAlarm;
+};
+declare function readEvent(bc: bare.ByteCursor): Event;
+declare function writeEvent(bc: bare.ByteCursor, x: Event): void;
+type EventWrapper = {
+    readonly checkpoint: ActorCheckpoint;
+    readonly inner: Event;
+};
+declare function readEventWrapper(bc: bare.ByteCursor): EventWrapper;
+declare function writeEventWrapper(bc: bare.ByteCursor, x: EventWrapper): void;
+type PreloadedKvEntry = {
+    readonly key: KvKey;
+    readonly value: KvValue;
+    readonly metadata: KvMetadata;
+};
+declare function readPreloadedKvEntry(bc: bare.ByteCursor): PreloadedKvEntry;
+declare function writePreloadedKvEntry(bc: bare.ByteCursor, x: PreloadedKvEntry): void;
+type PreloadedKv = {
+    readonly entries: readonly PreloadedKvEntry[];
+    readonly requestedGetKeys: readonly KvKey[];
+    readonly requestedPrefixes: readonly KvKey[];
+};
+declare function readPreloadedKv(bc: bare.ByteCursor): PreloadedKv;
+declare function writePreloadedKv(bc: bare.ByteCursor, x: PreloadedKv): void;
+type HibernatingRequest = {
+    readonly gatewayId: GatewayId;
+    readonly requestId: RequestId;
+};
+declare function readHibernatingRequest(bc: bare.ByteCursor): HibernatingRequest;
+declare function writeHibernatingRequest(bc: bare.ByteCursor, x: HibernatingRequest): void;
+type CommandStartActor = {
+    readonly config: ActorConfig;
+    readonly hibernatingRequests: readonly HibernatingRequest[];
+    readonly preloadedKv: PreloadedKv | null;
+};
+declare function readCommandStartActor(bc: bare.ByteCursor): CommandStartActor;
+declare function writeCommandStartActor(bc: bare.ByteCursor, x: CommandStartActor): void;
+declare enum StopActorReason {
+    SleepIntent = "SleepIntent",
+    StopIntent = "StopIntent",
+    Destroy = "Destroy",
+    GoingAway = "GoingAway",
+    Lost = "Lost"
+}
+declare function readStopActorReason(bc: bare.ByteCursor): StopActorReason;
+declare function writeStopActorReason(bc: bare.ByteCursor, x: StopActorReason): void;
+type CommandStopActor = {
+    readonly reason: StopActorReason;
+};
+declare function readCommandStopActor(bc: bare.ByteCursor): CommandStopActor;
+declare function writeCommandStopActor(bc: bare.ByteCursor, x: CommandStopActor): void;
+type Command = {
+    readonly tag: "CommandStartActor";
+    readonly val: CommandStartActor;
+} | {
+    readonly tag: "CommandStopActor";
+    readonly val: CommandStopActor;
+};
+declare function readCommand(bc: bare.ByteCursor): Command;
+declare function writeCommand(bc: bare.ByteCursor, x: Command): void;
+type CommandWrapper = {
+    readonly checkpoint: ActorCheckpoint;
+    readonly inner: Command;
+};
+declare function readCommandWrapper(bc: bare.ByteCursor): CommandWrapper;
+declare function writeCommandWrapper(bc: bare.ByteCursor, x: CommandWrapper): void;
+/**
+ * We redeclare this so its top level
+ */
+type ActorCommandKeyData = {
+    readonly tag: "CommandStartActor";
+    readonly val: CommandStartActor;
+} | {
+    readonly tag: "CommandStopActor";
+    readonly val: CommandStopActor;
+};
+declare function readActorCommandKeyData(bc: bare.ByteCursor): ActorCommandKeyData;
+declare function writeActorCommandKeyData(bc: bare.ByteCursor, x: ActorCommandKeyData): void;
+declare function encodeActorCommandKeyData(x: ActorCommandKeyData, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeActorCommandKeyData(bytes: Uint8Array): ActorCommandKeyData;
+type MessageId = {
+    /**
+     * Globally unique ID
+     */
+    readonly gatewayId: GatewayId;
+    /**
+     * Unique ID to the gateway
+     */
+    readonly requestId: RequestId;
+    /**
+     * Unique ID to the request
+     */
+    readonly messageIndex: MessageIndex;
+};
+declare function readMessageId(bc: bare.ByteCursor): MessageId;
+declare function writeMessageId(bc: bare.ByteCursor, x: MessageId): void;
+/**
+ * HTTP
+ */
+type ToEnvoyRequestStart = {
+    readonly actorId: Id;
+    /**
+     * Exact actor generation selected by Gateway 3. Legacy Gateway 2 requests
+     * omit this and retain highest-live-generation routing.
+     */
+    readonly actorGeneration: u32 | null;
+    readonly method: string;
+    readonly path: string;
+    readonly headers: ReadonlyMap<string, string>;
+    readonly body: ArrayBuffer | null;
+    readonly stream: boolean;
+    /**
+     * Whether the gateway can accept a streamed response body.
+     */
+    readonly responseStream: boolean;
+};
+declare function readToEnvoyRequestStart(bc: bare.ByteCursor): ToEnvoyRequestStart;
+declare function writeToEnvoyRequestStart(bc: bare.ByteCursor, x: ToEnvoyRequestStart): void;
+type ToEnvoyRequestChunk = {
+    readonly body: ArrayBuffer;
+    readonly finish: boolean;
+};
+declare function readToEnvoyRequestChunk(bc: bare.ByteCursor): ToEnvoyRequestChunk;
+declare function writeToEnvoyRequestChunk(bc: bare.ByteCursor, x: ToEnvoyRequestChunk): void;
+/**
+ * Cumulative request-body bytes consumed by the actor handler. This restores
+ * sender credit without requiring one acknowledgement per chunk.
+ */
+type ToRivetRequestBodyWindowUpdate = {
+    readonly consumedBytes: u64;
+};
+declare function readToRivetRequestBodyWindowUpdate(bc: bare.ByteCursor): ToRivetRequestBodyWindowUpdate;
+declare function writeToRivetRequestBodyWindowUpdate(bc: bare.ByteCursor, x: ToRivetRequestBodyWindowUpdate): void;
+/**
+ * The actor handler no longer wants request-body bytes. The HTTP response may
+ * still continue normally.
+ */
+type ToRivetRequestBodyCancel = null;
+declare enum HttpStreamAbortReasonKind {
+    Unknown = "Unknown",
+    Cancelled = "Cancelled",
+    HandlerError = "HandlerError",
+    InternalError = "InternalError"
+}
+declare function readHttpStreamAbortReasonKind(bc: bare.ByteCursor): HttpStreamAbortReasonKind;
+declare function writeHttpStreamAbortReasonKind(bc: bare.ByteCursor, x: HttpStreamAbortReasonKind): void;
+type HttpStreamAbortReason = {
+    readonly kind: HttpStreamAbortReasonKind;
+    readonly detail: string | null;
+};
+declare function readHttpStreamAbortReason(bc: bare.ByteCursor): HttpStreamAbortReason;
+declare function writeHttpStreamAbortReason(bc: bare.ByteCursor, x: HttpStreamAbortReason): void;
+type ToEnvoyRequestAbort = {
+    /**
+     * Exact admission identity. Gateway 3 always sets both fields so Envoy can
+     * suppress a delayed RequestStart after an indeterminate handoff.
+     */
+    readonly actorId: Id | null;
+    readonly actorGeneration: u32 | null;
+    readonly reason: HttpStreamAbortReason;
+};
+declare function readToEnvoyRequestAbort(bc: bare.ByteCursor): ToEnvoyRequestAbort;
+declare function writeToEnvoyRequestAbort(bc: bare.ByteCursor, x: ToEnvoyRequestAbort): void;
+/**
+ * Stop the actor-side request body without cancelling the HTTP response.
+ */
+type ToEnvoyRequestBodyCancel = null;
+type ToRivetResponseStart = {
+    readonly status: u16;
+    readonly headers: ReadonlyMap<string, string>;
+    readonly body: ArrayBuffer | null;
+    readonly stream: boolean;
+};
+declare function readToRivetResponseStart(bc: bare.ByteCursor): ToRivetResponseStart;
+declare function writeToRivetResponseStart(bc: bare.ByteCursor, x: ToRivetResponseStart): void;
+type ToRivetResponseChunk = {
+    readonly body: ArrayBuffer;
+    readonly finish: boolean;
+};
+declare function readToRivetResponseChunk(bc: bare.ByteCursor): ToRivetResponseChunk;
+declare function writeToRivetResponseChunk(bc: bare.ByteCursor, x: ToRivetResponseChunk): void;
+/**
+ * Cumulative response-body bytes consumed by the gateway client. This restores
+ * sender credit without requiring one acknowledgement per chunk.
+ */
+type ToEnvoyResponseBodyWindowUpdate = {
+    readonly consumedBytes: u64;
+};
+declare function readToEnvoyResponseBodyWindowUpdate(bc: bare.ByteCursor): ToEnvoyResponseBodyWindowUpdate;
+declare function writeToEnvoyResponseBodyWindowUpdate(bc: bare.ByteCursor, x: ToEnvoyResponseBodyWindowUpdate): void;
+type ToRivetResponseAbort = {
+    readonly reason: HttpStreamAbortReason;
+};
+declare function readToRivetResponseAbort(bc: bare.ByteCursor): ToRivetResponseAbort;
+declare function writeToRivetResponseAbort(bc: bare.ByteCursor, x: ToRivetResponseAbort): void;
+/**
+ * WebSocket
+ */
+type ToEnvoyWebSocketOpen = {
+    readonly actorId: Id;
+    /**
+     * Exact actor generation selected by Gateway 3. Legacy Gateway 2 requests
+     * omit this and retain highest-live-generation routing.
+     */
+    readonly actorGeneration: u32 | null;
+    readonly path: string;
+    readonly headers: ReadonlyMap<string, string>;
+};
+declare function readToEnvoyWebSocketOpen(bc: bare.ByteCursor): ToEnvoyWebSocketOpen;
+declare function writeToEnvoyWebSocketOpen(bc: bare.ByteCursor, x: ToEnvoyWebSocketOpen): void;
+type ToEnvoyWebSocketMessage = {
+    readonly data: ArrayBuffer;
+    readonly binary: boolean;
+};
+declare function readToEnvoyWebSocketMessage(bc: bare.ByteCursor): ToEnvoyWebSocketMessage;
+declare function writeToEnvoyWebSocketMessage(bc: bare.ByteCursor, x: ToEnvoyWebSocketMessage): void;
+type ToEnvoyWebSocketClose = {
+    readonly code: u16 | null;
+    readonly reason: string | null;
+};
+declare function readToEnvoyWebSocketClose(bc: bare.ByteCursor): ToEnvoyWebSocketClose;
+declare function writeToEnvoyWebSocketClose(bc: bare.ByteCursor, x: ToEnvoyWebSocketClose): void;
+type ToRivetWebSocketOpen = {
+    readonly canHibernate: boolean;
+};
+declare function readToRivetWebSocketOpen(bc: bare.ByteCursor): ToRivetWebSocketOpen;
+declare function writeToRivetWebSocketOpen(bc: bare.ByteCursor, x: ToRivetWebSocketOpen): void;
+type ToRivetWebSocketMessage = {
+    readonly data: ArrayBuffer;
+    readonly binary: boolean;
+};
+declare function readToRivetWebSocketMessage(bc: bare.ByteCursor): ToRivetWebSocketMessage;
+declare function writeToRivetWebSocketMessage(bc: bare.ByteCursor, x: ToRivetWebSocketMessage): void;
+type ToRivetWebSocketMessageAck = {
+    readonly index: MessageIndex;
+};
+declare function readToRivetWebSocketMessageAck(bc: bare.ByteCursor): ToRivetWebSocketMessageAck;
+declare function writeToRivetWebSocketMessageAck(bc: bare.ByteCursor, x: ToRivetWebSocketMessageAck): void;
+type ToRivetWebSocketClose = {
+    readonly code: u16 | null;
+    readonly reason: string | null;
+    readonly hibernate: boolean;
+};
+declare function readToRivetWebSocketClose(bc: bare.ByteCursor): ToRivetWebSocketClose;
+declare function writeToRivetWebSocketClose(bc: bare.ByteCursor, x: ToRivetWebSocketClose): void;
+/**
+ * To Rivet
+ */
+type ToRivetTunnelMessageKind = 
+/**
+ * HTTP
+ */
+{
+    readonly tag: "ToRivetResponseStart";
+    readonly val: ToRivetResponseStart;
+} | {
+    readonly tag: "ToRivetResponseChunk";
+    readonly val: ToRivetResponseChunk;
+} | {
+    readonly tag: "ToRivetResponseAbort";
+    readonly val: ToRivetResponseAbort;
+} | {
+    readonly tag: "ToRivetRequestBodyWindowUpdate";
+    readonly val: ToRivetRequestBodyWindowUpdate;
+} | {
+    readonly tag: "ToRivetRequestBodyCancel";
+    readonly val: ToRivetRequestBodyCancel;
+}
+/**
+ * WebSocket
+ */
+ | {
+    readonly tag: "ToRivetWebSocketOpen";
+    readonly val: ToRivetWebSocketOpen;
+} | {
+    readonly tag: "ToRivetWebSocketMessage";
+    readonly val: ToRivetWebSocketMessage;
+} | {
+    readonly tag: "ToRivetWebSocketMessageAck";
+    readonly val: ToRivetWebSocketMessageAck;
+} | {
+    readonly tag: "ToRivetWebSocketClose";
+    readonly val: ToRivetWebSocketClose;
+};
+declare function readToRivetTunnelMessageKind(bc: bare.ByteCursor): ToRivetTunnelMessageKind;
+declare function writeToRivetTunnelMessageKind(bc: bare.ByteCursor, x: ToRivetTunnelMessageKind): void;
+type ToRivetTunnelMessage = {
+    readonly messageId: MessageId;
+    readonly messageKind: ToRivetTunnelMessageKind;
+};
+declare function readToRivetTunnelMessage(bc: bare.ByteCursor): ToRivetTunnelMessage;
+declare function writeToRivetTunnelMessage(bc: bare.ByteCursor, x: ToRivetTunnelMessage): void;
+/**
+ * To Envoy
+ */
+type ToEnvoyTunnelMessageKind = 
+/**
+ * HTTP
+ */
+{
+    readonly tag: "ToEnvoyRequestStart";
+    readonly val: ToEnvoyRequestStart;
+} | {
+    readonly tag: "ToEnvoyRequestChunk";
+    readonly val: ToEnvoyRequestChunk;
+} | {
+    readonly tag: "ToEnvoyRequestAbort";
+    readonly val: ToEnvoyRequestAbort;
+} | {
+    readonly tag: "ToEnvoyRequestBodyCancel";
+    readonly val: ToEnvoyRequestBodyCancel;
+} | {
+    readonly tag: "ToEnvoyResponseBodyWindowUpdate";
+    readonly val: ToEnvoyResponseBodyWindowUpdate;
+}
+/**
+ * WebSocket
+ */
+ | {
+    readonly tag: "ToEnvoyWebSocketOpen";
+    readonly val: ToEnvoyWebSocketOpen;
+} | {
+    readonly tag: "ToEnvoyWebSocketMessage";
+    readonly val: ToEnvoyWebSocketMessage;
+} | {
+    readonly tag: "ToEnvoyWebSocketClose";
+    readonly val: ToEnvoyWebSocketClose;
+};
+declare function readToEnvoyTunnelMessageKind(bc: bare.ByteCursor): ToEnvoyTunnelMessageKind;
+declare function writeToEnvoyTunnelMessageKind(bc: bare.ByteCursor, x: ToEnvoyTunnelMessageKind): void;
+type ToEnvoyTunnelMessage = {
+    readonly messageId: MessageId;
+    readonly messageKind: ToEnvoyTunnelMessageKind;
+};
+declare function readToEnvoyTunnelMessage(bc: bare.ByteCursor): ToEnvoyTunnelMessage;
+declare function writeToEnvoyTunnelMessage(bc: bare.ByteCursor, x: ToEnvoyTunnelMessage): void;
+type ToEnvoyPing = {
+    readonly ts: i64;
+};
+declare function readToEnvoyPing(bc: bare.ByteCursor): ToEnvoyPing;
+declare function writeToEnvoyPing(bc: bare.ByteCursor, x: ToEnvoyPing): void;
+/**
+ * MARK: To Rivet
+ */
+type ToRivetMetadata = {
+    readonly prepopulateActorNames: ReadonlyMap<string, ActorName> | null;
+    readonly metadata: Json | null;
+};
+declare function readToRivetMetadata(bc: bare.ByteCursor): ToRivetMetadata;
+declare function writeToRivetMetadata(bc: bare.ByteCursor, x: ToRivetMetadata): void;
+type ToRivetEvents = readonly EventWrapper[];
+declare function readToRivetEvents(bc: bare.ByteCursor): ToRivetEvents;
+declare function writeToRivetEvents(bc: bare.ByteCursor, x: ToRivetEvents): void;
+type ToRivetAckCommands = {
+    readonly lastCommandCheckpoints: readonly ActorCheckpoint[];
+};
+declare function readToRivetAckCommands(bc: bare.ByteCursor): ToRivetAckCommands;
+declare function writeToRivetAckCommands(bc: bare.ByteCursor, x: ToRivetAckCommands): void;
+type ToRivetStopping = null;
+type ToRivetPong = {
+    readonly ts: i64;
+};
+declare function readToRivetPong(bc: bare.ByteCursor): ToRivetPong;
+declare function writeToRivetPong(bc: bare.ByteCursor, x: ToRivetPong): void;
+type ToRivetKvRequest = {
+    readonly actorId: Id;
+    readonly requestId: u32;
+    readonly data: KvRequestData;
+};
+declare function readToRivetKvRequest(bc: bare.ByteCursor): ToRivetKvRequest;
+declare function writeToRivetKvRequest(bc: bare.ByteCursor, x: ToRivetKvRequest): void;
+type ToRivetSqliteGetPagesRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteGetPagesRequest;
+};
+declare function readToRivetSqliteGetPagesRequest(bc: bare.ByteCursor): ToRivetSqliteGetPagesRequest;
+declare function writeToRivetSqliteGetPagesRequest(bc: bare.ByteCursor, x: ToRivetSqliteGetPagesRequest): void;
+type ToRivetSqliteCommitRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitRequest;
+};
+declare function readToRivetSqliteCommitRequest(bc: bare.ByteCursor): ToRivetSqliteCommitRequest;
+declare function writeToRivetSqliteCommitRequest(bc: bare.ByteCursor, x: ToRivetSqliteCommitRequest): void;
+type ToRivetSqliteCommitStageBeginRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitStageBeginRequest;
+};
+declare function readToRivetSqliteCommitStageBeginRequest(bc: bare.ByteCursor): ToRivetSqliteCommitStageBeginRequest;
+declare function writeToRivetSqliteCommitStageBeginRequest(bc: bare.ByteCursor, x: ToRivetSqliteCommitStageBeginRequest): void;
+type ToRivetSqliteCommitStageSegmentRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitStageSegmentRequest;
+};
+declare function readToRivetSqliteCommitStageSegmentRequest(bc: bare.ByteCursor): ToRivetSqliteCommitStageSegmentRequest;
+declare function writeToRivetSqliteCommitStageSegmentRequest(bc: bare.ByteCursor, x: ToRivetSqliteCommitStageSegmentRequest): void;
+type ToRivetSqliteCommitFinalizeRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitFinalizeRequest;
+};
+declare function readToRivetSqliteCommitFinalizeRequest(bc: bare.ByteCursor): ToRivetSqliteCommitFinalizeRequest;
+declare function writeToRivetSqliteCommitFinalizeRequest(bc: bare.ByteCursor, x: ToRivetSqliteCommitFinalizeRequest): void;
+type ToRivetSqliteExecRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteExecRequest;
+};
+declare function readToRivetSqliteExecRequest(bc: bare.ByteCursor): ToRivetSqliteExecRequest;
+declare function writeToRivetSqliteExecRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecRequest): void;
+type ToRivetSqliteExecuteRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteExecuteRequest;
+};
+declare function readToRivetSqliteExecuteRequest(bc: bare.ByteCursor): ToRivetSqliteExecuteRequest;
+declare function writeToRivetSqliteExecuteRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecuteRequest): void;
+type ToRivetSqliteExecuteBatchRequest = {
+    readonly requestId: u32;
+    readonly data: SqliteExecuteBatchRequest;
+};
+declare function readToRivetSqliteExecuteBatchRequest(bc: bare.ByteCursor): ToRivetSqliteExecuteBatchRequest;
+declare function writeToRivetSqliteExecuteBatchRequest(bc: bare.ByteCursor, x: ToRivetSqliteExecuteBatchRequest): void;
+type ToRivet = {
+    readonly tag: "ToRivetMetadata";
+    readonly val: ToRivetMetadata;
+} | {
+    readonly tag: "ToRivetEvents";
+    readonly val: ToRivetEvents;
+} | {
+    readonly tag: "ToRivetAckCommands";
+    readonly val: ToRivetAckCommands;
+} | {
+    readonly tag: "ToRivetStopping";
+    readonly val: ToRivetStopping;
+} | {
+    readonly tag: "ToRivetPong";
+    readonly val: ToRivetPong;
+} | {
+    readonly tag: "ToRivetKvRequest";
+    readonly val: ToRivetKvRequest;
+} | {
+    readonly tag: "ToRivetTunnelMessage";
+    readonly val: ToRivetTunnelMessage;
+} | {
+    readonly tag: "ToRivetSqliteGetPagesRequest";
+    readonly val: ToRivetSqliteGetPagesRequest;
+} | {
+    readonly tag: "ToRivetSqliteCommitRequest";
+    readonly val: ToRivetSqliteCommitRequest;
+} | {
+    readonly tag: "ToRivetSqliteCommitStageBeginRequest";
+    readonly val: ToRivetSqliteCommitStageBeginRequest;
+} | {
+    readonly tag: "ToRivetSqliteCommitStageSegmentRequest";
+    readonly val: ToRivetSqliteCommitStageSegmentRequest;
+} | {
+    readonly tag: "ToRivetSqliteCommitFinalizeRequest";
+    readonly val: ToRivetSqliteCommitFinalizeRequest;
+} | {
+    readonly tag: "ToRivetSqliteExecRequest";
+    readonly val: ToRivetSqliteExecRequest;
+} | {
+    readonly tag: "ToRivetSqliteExecuteRequest";
+    readonly val: ToRivetSqliteExecuteRequest;
+} | {
+    readonly tag: "ToRivetSqliteExecuteBatchRequest";
+    readonly val: ToRivetSqliteExecuteBatchRequest;
+};
+declare function readToRivet(bc: bare.ByteCursor): ToRivet;
+declare function writeToRivet(bc: bare.ByteCursor, x: ToRivet): void;
+declare function encodeToRivet(x: ToRivet, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToRivet(bytes: Uint8Array): ToRivet;
+/**
+ * MARK: To Envoy
+ */
+type ProtocolMetadata = {
+    readonly envoyLostThreshold: i64;
+    readonly actorStopThreshold: i64;
+    readonly maxResponsePayloadSize: u64;
+};
+declare function readProtocolMetadata(bc: bare.ByteCursor): ProtocolMetadata;
+declare function writeProtocolMetadata(bc: bare.ByteCursor, x: ProtocolMetadata): void;
+type ToEnvoyInit = {
+    readonly metadata: ProtocolMetadata;
+};
+declare function readToEnvoyInit(bc: bare.ByteCursor): ToEnvoyInit;
+declare function writeToEnvoyInit(bc: bare.ByteCursor, x: ToEnvoyInit): void;
+type ToEnvoyCommands = readonly CommandWrapper[];
+declare function readToEnvoyCommands(bc: bare.ByteCursor): ToEnvoyCommands;
+declare function writeToEnvoyCommands(bc: bare.ByteCursor, x: ToEnvoyCommands): void;
+type ToEnvoyAckEvents = {
+    readonly lastEventCheckpoints: readonly ActorCheckpoint[];
+};
+declare function readToEnvoyAckEvents(bc: bare.ByteCursor): ToEnvoyAckEvents;
+declare function writeToEnvoyAckEvents(bc: bare.ByteCursor, x: ToEnvoyAckEvents): void;
+type ToEnvoyKvResponse = {
+    readonly requestId: u32;
+    readonly data: KvResponseData;
+};
+declare function readToEnvoyKvResponse(bc: bare.ByteCursor): ToEnvoyKvResponse;
+declare function writeToEnvoyKvResponse(bc: bare.ByteCursor, x: ToEnvoyKvResponse): void;
+type ToEnvoySqliteGetPagesResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteGetPagesResponse;
+};
+declare function readToEnvoySqliteGetPagesResponse(bc: bare.ByteCursor): ToEnvoySqliteGetPagesResponse;
+declare function writeToEnvoySqliteGetPagesResponse(bc: bare.ByteCursor, x: ToEnvoySqliteGetPagesResponse): void;
+type ToEnvoySqliteCommitResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitResponse;
+};
+declare function readToEnvoySqliteCommitResponse(bc: bare.ByteCursor): ToEnvoySqliteCommitResponse;
+declare function writeToEnvoySqliteCommitResponse(bc: bare.ByteCursor, x: ToEnvoySqliteCommitResponse): void;
+type ToEnvoySqliteCommitStageBeginResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitStageBeginResponse;
+};
+declare function readToEnvoySqliteCommitStageBeginResponse(bc: bare.ByteCursor): ToEnvoySqliteCommitStageBeginResponse;
+declare function writeToEnvoySqliteCommitStageBeginResponse(bc: bare.ByteCursor, x: ToEnvoySqliteCommitStageBeginResponse): void;
+type ToEnvoySqliteCommitStageSegmentResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitStageSegmentResponse;
+};
+declare function readToEnvoySqliteCommitStageSegmentResponse(bc: bare.ByteCursor): ToEnvoySqliteCommitStageSegmentResponse;
+declare function writeToEnvoySqliteCommitStageSegmentResponse(bc: bare.ByteCursor, x: ToEnvoySqliteCommitStageSegmentResponse): void;
+type ToEnvoySqliteCommitFinalizeResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteCommitFinalizeResponse;
+};
+declare function readToEnvoySqliteCommitFinalizeResponse(bc: bare.ByteCursor): ToEnvoySqliteCommitFinalizeResponse;
+declare function writeToEnvoySqliteCommitFinalizeResponse(bc: bare.ByteCursor, x: ToEnvoySqliteCommitFinalizeResponse): void;
+type ToEnvoySqliteExecResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteExecResponse;
+};
+declare function readToEnvoySqliteExecResponse(bc: bare.ByteCursor): ToEnvoySqliteExecResponse;
+declare function writeToEnvoySqliteExecResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecResponse): void;
+type ToEnvoySqliteExecuteResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteExecuteResponse;
+};
+declare function readToEnvoySqliteExecuteResponse(bc: bare.ByteCursor): ToEnvoySqliteExecuteResponse;
+declare function writeToEnvoySqliteExecuteResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecuteResponse): void;
+type ToEnvoySqliteExecuteBatchResponse = {
+    readonly requestId: u32;
+    readonly data: SqliteExecuteBatchResponse;
+};
+declare function readToEnvoySqliteExecuteBatchResponse(bc: bare.ByteCursor): ToEnvoySqliteExecuteBatchResponse;
+declare function writeToEnvoySqliteExecuteBatchResponse(bc: bare.ByteCursor, x: ToEnvoySqliteExecuteBatchResponse): void;
+type ToEnvoy = {
+    readonly tag: "ToEnvoyInit";
+    readonly val: ToEnvoyInit;
+} | {
+    readonly tag: "ToEnvoyCommands";
+    readonly val: ToEnvoyCommands;
+} | {
+    readonly tag: "ToEnvoyAckEvents";
+    readonly val: ToEnvoyAckEvents;
+} | {
+    readonly tag: "ToEnvoyKvResponse";
+    readonly val: ToEnvoyKvResponse;
+} | {
+    readonly tag: "ToEnvoyTunnelMessage";
+    readonly val: ToEnvoyTunnelMessage;
+} | {
+    readonly tag: "ToEnvoyPing";
+    readonly val: ToEnvoyPing;
+} | {
+    readonly tag: "ToEnvoySqliteGetPagesResponse";
+    readonly val: ToEnvoySqliteGetPagesResponse;
+} | {
+    readonly tag: "ToEnvoySqliteCommitResponse";
+    readonly val: ToEnvoySqliteCommitResponse;
+} | {
+    readonly tag: "ToEnvoySqliteCommitStageBeginResponse";
+    readonly val: ToEnvoySqliteCommitStageBeginResponse;
+} | {
+    readonly tag: "ToEnvoySqliteCommitStageSegmentResponse";
+    readonly val: ToEnvoySqliteCommitStageSegmentResponse;
+} | {
+    readonly tag: "ToEnvoySqliteCommitFinalizeResponse";
+    readonly val: ToEnvoySqliteCommitFinalizeResponse;
+} | {
+    readonly tag: "ToEnvoySqliteExecResponse";
+    readonly val: ToEnvoySqliteExecResponse;
+} | {
+    readonly tag: "ToEnvoySqliteExecuteResponse";
+    readonly val: ToEnvoySqliteExecuteResponse;
+} | {
+    readonly tag: "ToEnvoySqliteExecuteBatchResponse";
+    readonly val: ToEnvoySqliteExecuteBatchResponse;
+};
+declare function readToEnvoy(bc: bare.ByteCursor): ToEnvoy;
+declare function writeToEnvoy(bc: bare.ByteCursor, x: ToEnvoy): void;
+declare function encodeToEnvoy(x: ToEnvoy, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToEnvoy(bytes: Uint8Array): ToEnvoy;
+/**
+ * MARK: To Envoy Conn
+ */
+type ToEnvoyConnPing = {
+    readonly gatewayId: GatewayId;
+    readonly requestId: RequestId;
+    readonly ts: i64;
+};
+declare function readToEnvoyConnPing(bc: bare.ByteCursor): ToEnvoyConnPing;
+declare function writeToEnvoyConnPing(bc: bare.ByteCursor, x: ToEnvoyConnPing): void;
+type ToEnvoyConnClose = null;
+type ToEnvoyConn = {
+    readonly tag: "ToEnvoyConnPing";
+    readonly val: ToEnvoyConnPing;
+} | {
+    readonly tag: "ToEnvoyConnClose";
+    readonly val: ToEnvoyConnClose;
+} | {
+    readonly tag: "ToEnvoyCommands";
+    readonly val: ToEnvoyCommands;
+} | {
+    readonly tag: "ToEnvoyAckEvents";
+    readonly val: ToEnvoyAckEvents;
+} | {
+    readonly tag: "ToEnvoyTunnelMessage";
+    readonly val: ToEnvoyTunnelMessage;
+};
+declare function readToEnvoyConn(bc: bare.ByteCursor): ToEnvoyConn;
+declare function writeToEnvoyConn(bc: bare.ByteCursor, x: ToEnvoyConn): void;
+declare function encodeToEnvoyConn(x: ToEnvoyConn, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToEnvoyConn(bytes: Uint8Array): ToEnvoyConn;
+/**
+ * MARK: To Gateway
+ */
+type ToGatewayPong = {
+    readonly requestId: RequestId;
+    readonly ts: i64;
+};
+declare function readToGatewayPong(bc: bare.ByteCursor): ToGatewayPong;
+declare function writeToGatewayPong(bc: bare.ByteCursor, x: ToGatewayPong): void;
+type ToGateway = {
+    readonly tag: "ToGatewayPong";
+    readonly val: ToGatewayPong;
+} | {
+    readonly tag: "ToRivetTunnelMessage";
+    readonly val: ToRivetTunnelMessage;
+};
+declare function readToGateway(bc: bare.ByteCursor): ToGateway;
+declare function writeToGateway(bc: bare.ByteCursor, x: ToGateway): void;
+declare function encodeToGateway(x: ToGateway, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToGateway(bytes: Uint8Array): ToGateway;
+/**
+ * MARK: To Outbound
+ */
+type ToOutboundActorStart = {
+    readonly namespaceId: Id;
+    readonly poolName: string;
+    readonly checkpoint: ActorCheckpoint;
+    readonly actorConfig: ActorConfig;
+};
+declare function readToOutboundActorStart(bc: bare.ByteCursor): ToOutboundActorStart;
+declare function writeToOutboundActorStart(bc: bare.ByteCursor, x: ToOutboundActorStart): void;
+type ToOutbound = {
+    readonly tag: "ToOutboundActorStart";
+    readonly val: ToOutboundActorStart;
+};
+declare function readToOutbound(bc: bare.ByteCursor): ToOutbound;
+declare function writeToOutbound(bc: bare.ByteCursor, x: ToOutbound): void;
+declare function encodeToOutbound(x: ToOutbound, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToOutbound(bytes: Uint8Array): ToOutbound;
+declare const VERSION = 8;
+
+export { type ActorCheckpoint, type ActorCommandKeyData, type ActorConfig, type ActorIntent, type ActorIntentSleep, type ActorIntentStop, type ActorName, type ActorState, type ActorStateRunning, type ActorStateStopped, type Command, type CommandStartActor, type CommandStopActor, type CommandWrapper, type Event, type EventActorIntent, type EventActorSetAlarm, type EventActorStateUpdate, type EventWrapper, type GatewayId, type HibernatingRequest, type HttpStreamAbortReason, HttpStreamAbortReasonKind, type Id, type Json, type KvDeleteRangeRequest, type KvDeleteRequest, type KvDeleteResponse, type KvDropRequest, type KvDropResponse, type KvErrorResponse, type KvGetRequest, type KvGetResponse, type KvKey, type KvListAllQuery, type KvListPrefixQuery, type KvListQuery, type KvListRangeQuery, type KvListRequest, type KvListResponse, type KvMetadata, type KvPutRequest, type KvPutResponse, type KvRequestData, type KvResponseData, type KvValue, type MessageId, type MessageIndex, type PreloadedKv, type PreloadedKvEntry, type ProtocolMetadata, type RequestId, type SqliteBatchStatement, type SqliteBindParam, type SqliteColumnValue, type SqliteCommitFinalizeOk, type SqliteCommitFinalizeRequest, type SqliteCommitFinalizeResponse, type SqliteCommitOk, type SqliteCommitRequest, type SqliteCommitResponse, type SqliteCommitStageBeginOk, type SqliteCommitStageBeginRequest, type SqliteCommitStageBeginResponse, type SqliteCommitStageSegmentOk, type SqliteCommitStageSegmentRequest, type SqliteCommitStageSegmentResponse, type SqliteDirtyPage, type SqliteErrorResponse, type SqliteExecOk, type SqliteExecRequest, type SqliteExecResponse, type SqliteExecuteBatchOk, type SqliteExecuteBatchRequest, type SqliteExecuteBatchResponse, type SqliteExecuteOk, type SqliteExecuteRequest, type SqliteExecuteResponse, type SqliteExecuteResult, type SqliteFetchedPage, type SqliteGeneration, type SqliteGetPagesOk, type SqliteGetPagesRequest, type SqliteGetPagesResponse, type SqlitePageBytes, type SqlitePgno, type SqliteQueryResult, type SqliteValueBlob, type SqliteValueFloat, type SqliteValueInteger, type SqliteValueNull, type SqliteValueText, StopActorReason, StopCode, type ToEnvoy, type ToEnvoyAckEvents, type ToEnvoyCommands, type ToEnvoyConn, type ToEnvoyConnClose, type ToEnvoyConnPing, type ToEnvoyInit, type ToEnvoyKvResponse, type ToEnvoyPing, type ToEnvoyRequestAbort, type ToEnvoyRequestBodyCancel, type ToEnvoyRequestChunk, type ToEnvoyRequestStart, type ToEnvoyResponseBodyWindowUpdate, type ToEnvoySqliteCommitFinalizeResponse, type ToEnvoySqliteCommitResponse, type ToEnvoySqliteCommitStageBeginResponse, type ToEnvoySqliteCommitStageSegmentResponse, type ToEnvoySqliteExecResponse, type ToEnvoySqliteExecuteBatchResponse, type ToEnvoySqliteExecuteResponse, type ToEnvoySqliteGetPagesResponse, type ToEnvoyTunnelMessage, type ToEnvoyTunnelMessageKind, type ToEnvoyWebSocketClose, type ToEnvoyWebSocketMessage, type ToEnvoyWebSocketOpen, type ToGateway, type ToGatewayPong, type ToOutbound, type ToOutboundActorStart, type ToRivet, type ToRivetAckCommands, type ToRivetEvents, type ToRivetKvRequest, type ToRivetMetadata, type ToRivetPong, type ToRivetRequestBodyCancel, type ToRivetRequestBodyWindowUpdate, type ToRivetResponseAbort, type ToRivetResponseChunk, type ToRivetResponseStart, type ToRivetSqliteCommitFinalizeRequest, type ToRivetSqliteCommitRequest, type ToRivetSqliteCommitStageBeginRequest, type ToRivetSqliteCommitStageSegmentRequest, type ToRivetSqliteExecRequest, type ToRivetSqliteExecuteBatchRequest, type ToRivetSqliteExecuteRequest, type ToRivetSqliteGetPagesRequest, type ToRivetStopping, type ToRivetTunnelMessage, type ToRivetTunnelMessageKind, type ToRivetWebSocketClose, type ToRivetWebSocketMessage, type ToRivetWebSocketMessageAck, type ToRivetWebSocketOpen, VERSION, decodeActorCommandKeyData, decodeToEnvoy, decodeToEnvoyConn, decodeToGateway, decodeToOutbound, decodeToRivet, encodeActorCommandKeyData, encodeToEnvoy, encodeToEnvoyConn, encodeToGateway, encodeToOutbound, encodeToRivet, type i64, readActorCheckpoint, readActorCommandKeyData, readActorConfig, readActorIntent, readActorName, readActorState, readActorStateStopped, readCommand, readCommandStartActor, readCommandStopActor, readCommandWrapper, readEvent, readEventActorIntent, readEventActorSetAlarm, readEventActorStateUpdate, readEventWrapper, readGatewayId, readHibernatingRequest, readHttpStreamAbortReason, readHttpStreamAbortReasonKind, readId, readJson, readKvDeleteRangeRequest, readKvDeleteRequest, readKvErrorResponse, readKvGetRequest, readKvGetResponse, readKvKey, readKvListPrefixQuery, readKvListQuery, readKvListRangeQuery, readKvListRequest, readKvListResponse, readKvMetadata, readKvPutRequest, readKvRequestData, readKvResponseData, readKvValue, readMessageId, readMessageIndex, readPreloadedKv, readPreloadedKvEntry, readProtocolMetadata, readRequestId, readSqliteBatchStatement, readSqliteBindParam, readSqliteColumnValue, readSqliteCommitFinalizeOk, readSqliteCommitFinalizeRequest, readSqliteCommitFinalizeResponse, readSqliteCommitOk, readSqliteCommitRequest, readSqliteCommitResponse, readSqliteCommitStageBeginOk, readSqliteCommitStageBeginRequest, readSqliteCommitStageBeginResponse, readSqliteCommitStageSegmentOk, readSqliteCommitStageSegmentRequest, readSqliteCommitStageSegmentResponse, readSqliteDirtyPage, readSqliteErrorResponse, readSqliteExecOk, readSqliteExecRequest, readSqliteExecResponse, readSqliteExecuteBatchOk, readSqliteExecuteBatchRequest, readSqliteExecuteBatchResponse, readSqliteExecuteOk, readSqliteExecuteRequest, readSqliteExecuteResponse, readSqliteExecuteResult, readSqliteFetchedPage, readSqliteGeneration, readSqliteGetPagesOk, readSqliteGetPagesRequest, readSqliteGetPagesResponse, readSqlitePageBytes, readSqlitePgno, readSqliteQueryResult, readSqliteValueBlob, readSqliteValueFloat, readSqliteValueInteger, readSqliteValueText, readStopActorReason, readStopCode, readToEnvoy, readToEnvoyAckEvents, readToEnvoyCommands, readToEnvoyConn, readToEnvoyConnPing, readToEnvoyInit, readToEnvoyKvResponse, readToEnvoyPing, readToEnvoyRequestAbort, readToEnvoyRequestChunk, readToEnvoyRequestStart, readToEnvoyResponseBodyWindowUpdate, readToEnvoySqliteCommitFinalizeResponse, readToEnvoySqliteCommitResponse, readToEnvoySqliteCommitStageBeginResponse, readToEnvoySqliteCommitStageSegmentResponse, readToEnvoySqliteExecResponse, readToEnvoySqliteExecuteBatchResponse, readToEnvoySqliteExecuteResponse, readToEnvoySqliteGetPagesResponse, readToEnvoyTunnelMessage, readToEnvoyTunnelMessageKind, readToEnvoyWebSocketClose, readToEnvoyWebSocketMessage, readToEnvoyWebSocketOpen, readToGateway, readToGatewayPong, readToOutbound, readToOutboundActorStart, readToRivet, readToRivetAckCommands, readToRivetEvents, readToRivetKvRequest, readToRivetMetadata, readToRivetPong, readToRivetRequestBodyWindowUpdate, readToRivetResponseAbort, readToRivetResponseChunk, readToRivetResponseStart, readToRivetSqliteCommitFinalizeRequest, readToRivetSqliteCommitRequest, readToRivetSqliteCommitStageBeginRequest, readToRivetSqliteCommitStageSegmentRequest, readToRivetSqliteExecRequest, readToRivetSqliteExecuteBatchRequest, readToRivetSqliteExecuteRequest, readToRivetSqliteGetPagesRequest, readToRivetTunnelMessage, readToRivetTunnelMessageKind, readToRivetWebSocketClose, readToRivetWebSocketMessage, readToRivetWebSocketMessageAck, readToRivetWebSocketOpen, type u16, type u32, type u64, writeActorCheckpoint, writeActorCommandKeyData, writeActorConfig, writeActorIntent, writeActorName, writeActorState, writeActorStateStopped, writeCommand, writeCommandStartActor, writeCommandStopActor, writeCommandWrapper, writeEvent, writeEventActorIntent, writeEventActorSetAlarm, writeEventActorStateUpdate, writeEventWrapper, writeGatewayId, writeHibernatingRequest, writeHttpStreamAbortReason, writeHttpStreamAbortReasonKind, writeId, writeJson, writeKvDeleteRangeRequest, writeKvDeleteRequest, writeKvErrorResponse, writeKvGetRequest, writeKvGetResponse, writeKvKey, writeKvListPrefixQuery, writeKvListQuery, writeKvListRangeQuery, writeKvListRequest, writeKvListResponse, writeKvMetadata, writeKvPutRequest, writeKvRequestData, writeKvResponseData, writeKvValue, writeMessageId, writeMessageIndex, writePreloadedKv, writePreloadedKvEntry, writeProtocolMetadata, writeRequestId, writeSqliteBatchStatement, writeSqliteBindParam, writeSqliteColumnValue, writeSqliteCommitFinalizeOk, writeSqliteCommitFinalizeRequest, writeSqliteCommitFinalizeResponse, writeSqliteCommitOk, writeSqliteCommitRequest, writeSqliteCommitResponse, writeSqliteCommitStageBeginOk, writeSqliteCommitStageBeginRequest, writeSqliteCommitStageBeginResponse, writeSqliteCommitStageSegmentOk, writeSqliteCommitStageSegmentRequest, writeSqliteCommitStageSegmentResponse, writeSqliteDirtyPage, writeSqliteErrorResponse, writeSqliteExecOk, writeSqliteExecRequest, writeSqliteExecResponse, writeSqliteExecuteBatchOk, writeSqliteExecuteBatchRequest, writeSqliteExecuteBatchResponse, writeSqliteExecuteOk, writeSqliteExecuteRequest, writeSqliteExecuteResponse, writeSqliteExecuteResult, writeSqliteFetchedPage, writeSqliteGeneration, writeSqliteGetPagesOk, writeSqliteGetPagesRequest, writeSqliteGetPagesResponse, writeSqlitePageBytes, writeSqlitePgno, writeSqliteQueryResult, writeSqliteValueBlob, writeSqliteValueFloat, writeSqliteValueInteger, writeSqliteValueText, writeStopActorReason, writeStopCode, writeToEnvoy, writeToEnvoyAckEvents, writeToEnvoyCommands, writeToEnvoyConn, writeToEnvoyConnPing, writeToEnvoyInit, writeToEnvoyKvResponse, writeToEnvoyPing, writeToEnvoyRequestAbort, writeToEnvoyRequestChunk, writeToEnvoyRequestStart, writeToEnvoyResponseBodyWindowUpdate, writeToEnvoySqliteCommitFinalizeResponse, writeToEnvoySqliteCommitResponse, writeToEnvoySqliteCommitStageBeginResponse, writeToEnvoySqliteCommitStageSegmentResponse, writeToEnvoySqliteExecResponse, writeToEnvoySqliteExecuteBatchResponse, writeToEnvoySqliteExecuteResponse, writeToEnvoySqliteGetPagesResponse, writeToEnvoyTunnelMessage, writeToEnvoyTunnelMessageKind, writeToEnvoyWebSocketClose, writeToEnvoyWebSocketMessage, writeToEnvoyWebSocketOpen, writeToGateway, writeToGatewayPong, writeToOutbound, writeToOutboundActorStart, writeToRivet, writeToRivetAckCommands, writeToRivetEvents, writeToRivetKvRequest, writeToRivetMetadata, writeToRivetPong, writeToRivetRequestBodyWindowUpdate, writeToRivetResponseAbort, writeToRivetResponseChunk, writeToRivetResponseStart, writeToRivetSqliteCommitFinalizeRequest, writeToRivetSqliteCommitRequest, writeToRivetSqliteCommitStageBeginRequest, writeToRivetSqliteCommitStageSegmentRequest, writeToRivetSqliteExecRequest, writeToRivetSqliteExecuteBatchRequest, writeToRivetSqliteExecuteRequest, writeToRivetSqliteGetPagesRequest, writeToRivetTunnelMessage, writeToRivetTunnelMessageKind, writeToRivetWebSocketClose, writeToRivetWebSocketMessage, writeToRivetWebSocketMessageAck, writeToRivetWebSocketOpen };