rivetkit 2.3.3 → 2.3.5-rc.1

package/src/common/bare/generated/inspector/v6.ts

@@ -0,0 +1,1367 @@
+// @generated - post-processed by build.rs
+import * as bare from "@rivetkit/bare-ts"
+
+const DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({})
+
+export type uint = bigint
+
+export type State = ArrayBuffer
+
+export function readState(bc: bare.ByteCursor): State {
+    return bare.readData(bc)
+}
+
+export function writeState(bc: bare.ByteCursor, x: State): void {
+    bare.writeData(bc, x)
+}
+
+export type WorkflowHistory = ArrayBuffer
+
+export function readWorkflowHistory(bc: bare.ByteCursor): WorkflowHistory {
+    return bare.readData(bc)
+}
+
+export function writeWorkflowHistory(bc: bare.ByteCursor, x: WorkflowHistory): void {
+    bare.writeData(bc, x)
+}
+
+export type PatchStateRequest = {
+    readonly state: ArrayBuffer
+}
+
+export function readPatchStateRequest(bc: bare.ByteCursor): PatchStateRequest {
+    return {
+        state: bare.readData(bc),
+    }
+}
+
+export function writePatchStateRequest(bc: bare.ByteCursor, x: PatchStateRequest): void {
+    bare.writeData(bc, x.state)
+}
+
+export type ActionRequest = {
+    readonly id: uint
+    readonly name: string
+    readonly args: ArrayBuffer
+}
+
+export function readActionRequest(bc: bare.ByteCursor): ActionRequest {
+    return {
+        id: bare.readUint(bc),
+        name: bare.readString(bc),
+        args: bare.readData(bc),
+    }
+}
+
+export function writeActionRequest(bc: bare.ByteCursor, x: ActionRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeString(bc, x.name)
+    bare.writeData(bc, x.args)
+}
+
+export type StateRequest = {
+    readonly id: uint
+}
+
+export function readStateRequest(bc: bare.ByteCursor): StateRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeStateRequest(bc: bare.ByteCursor, x: StateRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+export type ConnectionsRequest = {
+    readonly id: uint
+}
+
+export function readConnectionsRequest(bc: bare.ByteCursor): ConnectionsRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeConnectionsRequest(bc: bare.ByteCursor, x: ConnectionsRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+export type RpcsListRequest = {
+    readonly id: uint
+}
+
+export function readRpcsListRequest(bc: bare.ByteCursor): RpcsListRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeRpcsListRequest(bc: bare.ByteCursor, x: RpcsListRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+export type TraceQueryRequest = {
+    readonly id: uint
+    readonly startMs: uint
+    readonly endMs: uint
+    readonly limit: uint
+}
+
+export function readTraceQueryRequest(bc: bare.ByteCursor): TraceQueryRequest {
+    return {
+        id: bare.readUint(bc),
+        startMs: bare.readUint(bc),
+        endMs: bare.readUint(bc),
+        limit: bare.readUint(bc),
+    }
+}
+
+export function writeTraceQueryRequest(bc: bare.ByteCursor, x: TraceQueryRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeUint(bc, x.startMs)
+    bare.writeUint(bc, x.endMs)
+    bare.writeUint(bc, x.limit)
+}
+
+export type QueueRequest = {
+    readonly id: uint
+    readonly limit: uint
+}
+
+export function readQueueRequest(bc: bare.ByteCursor): QueueRequest {
+    return {
+        id: bare.readUint(bc),
+        limit: bare.readUint(bc),
+    }
+}
+
+export function writeQueueRequest(bc: bare.ByteCursor, x: QueueRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeUint(bc, x.limit)
+}
+
+export type WorkflowHistoryRequest = {
+    readonly id: uint
+}
+
+export function readWorkflowHistoryRequest(bc: bare.ByteCursor): WorkflowHistoryRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeWorkflowHistoryRequest(bc: bare.ByteCursor, x: WorkflowHistoryRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+function read0(bc: bare.ByteCursor): string | null {
+    return bare.readBool(bc) ? bare.readString(bc) : null
+}
+
+function write0(bc: bare.ByteCursor, x: string | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        bare.writeString(bc, x)
+    }
+}
+
+export type WorkflowReplayRequest = {
+    readonly id: uint
+    readonly entryId: string | null
+}
+
+export function readWorkflowReplayRequest(bc: bare.ByteCursor): WorkflowReplayRequest {
+    return {
+        id: bare.readUint(bc),
+        entryId: read0(bc),
+    }
+}
+
+export function writeWorkflowReplayRequest(bc: bare.ByteCursor, x: WorkflowReplayRequest): void {
+    bare.writeUint(bc, x.id)
+    write0(bc, x.entryId)
+}
+
+export type DatabaseSchemaRequest = {
+    readonly id: uint
+}
+
+export function readDatabaseSchemaRequest(bc: bare.ByteCursor): DatabaseSchemaRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeDatabaseSchemaRequest(bc: bare.ByteCursor, x: DatabaseSchemaRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+export type DatabaseTableRowsRequest = {
+    readonly id: uint
+    readonly table: string
+    readonly limit: uint
+    readonly offset: uint
+}
+
+export function readDatabaseTableRowsRequest(bc: bare.ByteCursor): DatabaseTableRowsRequest {
+    return {
+        id: bare.readUint(bc),
+        table: bare.readString(bc),
+        limit: bare.readUint(bc),
+        offset: bare.readUint(bc),
+    }
+}
+
+export function writeDatabaseTableRowsRequest(bc: bare.ByteCursor, x: DatabaseTableRowsRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeString(bc, x.table)
+    bare.writeUint(bc, x.limit)
+    bare.writeUint(bc, x.offset)
+}
+
+export type SchedulesRequest = {
+    readonly id: uint
+}
+
+export function readSchedulesRequest(bc: bare.ByteCursor): SchedulesRequest {
+    return {
+        id: bare.readUint(bc),
+    }
+}
+
+export function writeSchedulesRequest(bc: bare.ByteCursor, x: SchedulesRequest): void {
+    bare.writeUint(bc, x.id)
+}
+
+export type ScheduleHistoryRequest = {
+    readonly id: uint
+    readonly scheduleId: string
+    readonly limit: uint
+}
+
+export function readScheduleHistoryRequest(bc: bare.ByteCursor): ScheduleHistoryRequest {
+    return {
+        id: bare.readUint(bc),
+        scheduleId: bare.readString(bc),
+        limit: bare.readUint(bc),
+    }
+}
+
+export function writeScheduleHistoryRequest(bc: bare.ByteCursor, x: ScheduleHistoryRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeString(bc, x.scheduleId)
+    bare.writeUint(bc, x.limit)
+}
+
+export type ScheduleDeleteRequest = {
+    readonly id: uint
+    readonly scheduleId: string
+    readonly kind: string
+}
+
+export function readScheduleDeleteRequest(bc: bare.ByteCursor): ScheduleDeleteRequest {
+    return {
+        id: bare.readUint(bc),
+        scheduleId: bare.readString(bc),
+        kind: bare.readString(bc),
+    }
+}
+
+export function writeScheduleDeleteRequest(bc: bare.ByteCursor, x: ScheduleDeleteRequest): void {
+    bare.writeUint(bc, x.id)
+    bare.writeString(bc, x.scheduleId)
+    bare.writeString(bc, x.kind)
+}
+
+export type ToServerBody =
+    | { readonly tag: "PatchStateRequest"; readonly val: PatchStateRequest }
+    | { readonly tag: "StateRequest"; readonly val: StateRequest }
+    | { readonly tag: "ConnectionsRequest"; readonly val: ConnectionsRequest }
+    | { readonly tag: "ActionRequest"; readonly val: ActionRequest }
+    | { readonly tag: "RpcsListRequest"; readonly val: RpcsListRequest }
+    | { readonly tag: "TraceQueryRequest"; readonly val: TraceQueryRequest }
+    | { readonly tag: "QueueRequest"; readonly val: QueueRequest }
+    | { readonly tag: "WorkflowHistoryRequest"; readonly val: WorkflowHistoryRequest }
+    | { readonly tag: "WorkflowReplayRequest"; readonly val: WorkflowReplayRequest }
+    | { readonly tag: "DatabaseSchemaRequest"; readonly val: DatabaseSchemaRequest }
+    | { readonly tag: "DatabaseTableRowsRequest"; readonly val: DatabaseTableRowsRequest }
+    | { readonly tag: "SchedulesRequest"; readonly val: SchedulesRequest }
+    | { readonly tag: "ScheduleHistoryRequest"; readonly val: ScheduleHistoryRequest }
+    | { readonly tag: "ScheduleDeleteRequest"; readonly val: ScheduleDeleteRequest }
+
+export function readToServerBody(bc: bare.ByteCursor): ToServerBody {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "PatchStateRequest", val: readPatchStateRequest(bc) }
+        case 1:
+            return { tag: "StateRequest", val: readStateRequest(bc) }
+        case 2:
+            return { tag: "ConnectionsRequest", val: readConnectionsRequest(bc) }
+        case 3:
+            return { tag: "ActionRequest", val: readActionRequest(bc) }
+        case 4:
+            return { tag: "RpcsListRequest", val: readRpcsListRequest(bc) }
+        case 5:
+            return { tag: "TraceQueryRequest", val: readTraceQueryRequest(bc) }
+        case 6:
+            return { tag: "QueueRequest", val: readQueueRequest(bc) }
+        case 7:
+            return { tag: "WorkflowHistoryRequest", val: readWorkflowHistoryRequest(bc) }
+        case 8:
+            return { tag: "WorkflowReplayRequest", val: readWorkflowReplayRequest(bc) }
+        case 9:
+            return { tag: "DatabaseSchemaRequest", val: readDatabaseSchemaRequest(bc) }
+        case 10:
+            return { tag: "DatabaseTableRowsRequest", val: readDatabaseTableRowsRequest(bc) }
+        case 11:
+            return { tag: "SchedulesRequest", val: readSchedulesRequest(bc) }
+        case 12:
+            return { tag: "ScheduleHistoryRequest", val: readScheduleHistoryRequest(bc) }
+        case 13:
+            return { tag: "ScheduleDeleteRequest", val: readScheduleDeleteRequest(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeToServerBody(bc: bare.ByteCursor, x: ToServerBody): void {
+    switch (x.tag) {
+        case "PatchStateRequest": {
+            bare.writeU8(bc, 0)
+            writePatchStateRequest(bc, x.val)
+            break
+        }
+        case "StateRequest": {
+            bare.writeU8(bc, 1)
+            writeStateRequest(bc, x.val)
+            break
+        }
+        case "ConnectionsRequest": {
+            bare.writeU8(bc, 2)
+            writeConnectionsRequest(bc, x.val)
+            break
+        }
+        case "ActionRequest": {
+            bare.writeU8(bc, 3)
+            writeActionRequest(bc, x.val)
+            break
+        }
+        case "RpcsListRequest": {
+            bare.writeU8(bc, 4)
+            writeRpcsListRequest(bc, x.val)
+            break
+        }
+        case "TraceQueryRequest": {
+            bare.writeU8(bc, 5)
+            writeTraceQueryRequest(bc, x.val)
+            break
+        }
+        case "QueueRequest": {
+            bare.writeU8(bc, 6)
+            writeQueueRequest(bc, x.val)
+            break
+        }
+        case "WorkflowHistoryRequest": {
+            bare.writeU8(bc, 7)
+            writeWorkflowHistoryRequest(bc, x.val)
+            break
+        }
+        case "WorkflowReplayRequest": {
+            bare.writeU8(bc, 8)
+            writeWorkflowReplayRequest(bc, x.val)
+            break
+        }
+        case "DatabaseSchemaRequest": {
+            bare.writeU8(bc, 9)
+            writeDatabaseSchemaRequest(bc, x.val)
+            break
+        }
+        case "DatabaseTableRowsRequest": {
+            bare.writeU8(bc, 10)
+            writeDatabaseTableRowsRequest(bc, x.val)
+            break
+        }
+        case "SchedulesRequest": {
+            bare.writeU8(bc, 11)
+            writeSchedulesRequest(bc, x.val)
+            break
+        }
+        case "ScheduleHistoryRequest": {
+            bare.writeU8(bc, 12)
+            writeScheduleHistoryRequest(bc, x.val)
+            break
+        }
+        case "ScheduleDeleteRequest": {
+            bare.writeU8(bc, 13)
+            writeScheduleDeleteRequest(bc, x.val)
+            break
+        }
+    }
+}
+
+export type ToServer = {
+    readonly body: ToServerBody
+}
+
+export function readToServer(bc: bare.ByteCursor): ToServer {
+    return {
+        body: readToServerBody(bc),
+    }
+}
+
+export function writeToServer(bc: bare.ByteCursor, x: ToServer): void {
+    writeToServerBody(bc, x.body)
+}
+
+export function encodeToServer(x: ToServer, config?: Partial<bare.Config>): Uint8Array {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG
+    const bc = new bare.ByteCursor(
+        new Uint8Array(fullConfig.initialBufferLength),
+        fullConfig,
+    )
+    writeToServer(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeToServer(bytes: Uint8Array): ToServer {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG)
+    const result = readToServer(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+export type Connection = {
+    readonly id: string
+    readonly details: ArrayBuffer
+}
+
+export function readConnection(bc: bare.ByteCursor): Connection {
+    return {
+        id: bare.readString(bc),
+        details: bare.readData(bc),
+    }
+}
+
+export function writeConnection(bc: bare.ByteCursor, x: Connection): void {
+    bare.writeString(bc, x.id)
+    bare.writeData(bc, x.details)
+}
+
+/**
+ * Inspector tab descriptor. `label`/`icon` are set for author-declared custom
+ * tabs; a hidden built-in only carries `id` with `hidden` set.
+ */
+export type TabConfigEntry = {
+    readonly id: string
+    readonly label: string | null
+    readonly icon: string | null
+    readonly hidden: boolean
+}
+
+export function readTabConfigEntry(bc: bare.ByteCursor): TabConfigEntry {
+    return {
+        id: bare.readString(bc),
+        label: read0(bc),
+        icon: read0(bc),
+        hidden: bare.readBool(bc),
+    }
+}
+
+export function writeTabConfigEntry(bc: bare.ByteCursor, x: TabConfigEntry): void {
+    bare.writeString(bc, x.id)
+    write0(bc, x.label)
+    write0(bc, x.icon)
+    bare.writeBool(bc, x.hidden)
+}
+
+function read1(bc: bare.ByteCursor): uint | null {
+    return bare.readBool(bc) ? bare.readUint(bc) : null
+}
+
+function write1(bc: bare.ByteCursor, x: uint | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        bare.writeUint(bc, x)
+    }
+}
+
+export type Schedule = {
+    readonly id: string
+    readonly name: string | null
+    readonly kind: string
+    readonly action: string
+    readonly args: ArrayBuffer
+    readonly nextRunAt: uint
+    readonly lastRunAt: uint | null
+    readonly expression: string | null
+    readonly timezone: string | null
+    readonly intervalMs: uint | null
+    readonly maxHistory: uint | null
+}
+
+export function readSchedule(bc: bare.ByteCursor): Schedule {
+    return {
+        id: bare.readString(bc),
+        name: read0(bc),
+        kind: bare.readString(bc),
+        action: bare.readString(bc),
+        args: bare.readData(bc),
+        nextRunAt: bare.readUint(bc),
+        lastRunAt: read1(bc),
+        expression: read0(bc),
+        timezone: read0(bc),
+        intervalMs: read1(bc),
+        maxHistory: read1(bc),
+    }
+}
+
+export function writeSchedule(bc: bare.ByteCursor, x: Schedule): void {
+    bare.writeString(bc, x.id)
+    write0(bc, x.name)
+    bare.writeString(bc, x.kind)
+    bare.writeString(bc, x.action)
+    bare.writeData(bc, x.args)
+    bare.writeUint(bc, x.nextRunAt)
+    write1(bc, x.lastRunAt)
+    write0(bc, x.expression)
+    write0(bc, x.timezone)
+    write1(bc, x.intervalMs)
+    write1(bc, x.maxHistory)
+}
+
+function read2(bc: bare.ByteCursor): ArrayBuffer | null {
+    return bare.readBool(bc) ? bare.readData(bc) : null
+}
+
+function write2(bc: bare.ByteCursor, x: ArrayBuffer | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        bare.writeData(bc, x)
+    }
+}
+
+export type ScheduleError = {
+    readonly group: string
+    readonly code: string
+    readonly message: string
+    readonly metadata: ArrayBuffer | null
+}
+
+export function readScheduleError(bc: bare.ByteCursor): ScheduleError {
+    return {
+        group: bare.readString(bc),
+        code: bare.readString(bc),
+        message: bare.readString(bc),
+        metadata: read2(bc),
+    }
+}
+
+export function writeScheduleError(bc: bare.ByteCursor, x: ScheduleError): void {
+    bare.writeString(bc, x.group)
+    bare.writeString(bc, x.code)
+    bare.writeString(bc, x.message)
+    write2(bc, x.metadata)
+}
+
+function read3(bc: bare.ByteCursor): ScheduleError | null {
+    return bare.readBool(bc) ? readScheduleError(bc) : null
+}
+
+function write3(bc: bare.ByteCursor, x: ScheduleError | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        writeScheduleError(bc, x)
+    }
+}
+
+export type ScheduleFire = {
+    readonly action: string
+    readonly scheduledAt: uint
+    readonly firedAt: uint
+    readonly finishedAt: uint | null
+    readonly result: string
+    readonly error: ScheduleError | null
+}
+
+export function readScheduleFire(bc: bare.ByteCursor): ScheduleFire {
+    return {
+        action: bare.readString(bc),
+        scheduledAt: bare.readUint(bc),
+        firedAt: bare.readUint(bc),
+        finishedAt: read1(bc),
+        result: bare.readString(bc),
+        error: read3(bc),
+    }
+}
+
+export function writeScheduleFire(bc: bare.ByteCursor, x: ScheduleFire): void {
+    bare.writeString(bc, x.action)
+    bare.writeUint(bc, x.scheduledAt)
+    bare.writeUint(bc, x.firedAt)
+    write1(bc, x.finishedAt)
+    bare.writeString(bc, x.result)
+    write3(bc, x.error)
+}
+
+function read4(bc: bare.ByteCursor): readonly Connection[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readConnection(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readConnection(bc)
+    }
+    return result
+}
+
+function write4(bc: bare.ByteCursor, x: readonly Connection[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeConnection(bc, x[i])
+    }
+}
+
+function read5(bc: bare.ByteCursor): State | null {
+    return bare.readBool(bc) ? readState(bc) : null
+}
+
+function write5(bc: bare.ByteCursor, x: State | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        writeState(bc, x)
+    }
+}
+
+function read6(bc: bare.ByteCursor): readonly string[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [bare.readString(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = bare.readString(bc)
+    }
+    return result
+}
+
+function write6(bc: bare.ByteCursor, x: readonly string[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        bare.writeString(bc, x[i])
+    }
+}
+
+function read7(bc: bare.ByteCursor): WorkflowHistory | null {
+    return bare.readBool(bc) ? readWorkflowHistory(bc) : null
+}
+
+function write7(bc: bare.ByteCursor, x: WorkflowHistory | null): void {
+    bare.writeBool(bc, x != null)
+    if (x != null) {
+        writeWorkflowHistory(bc, x)
+    }
+}
+
+function read8(bc: bare.ByteCursor): readonly TabConfigEntry[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readTabConfigEntry(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readTabConfigEntry(bc)
+    }
+    return result
+}
+
+function write8(bc: bare.ByteCursor, x: readonly TabConfigEntry[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeTabConfigEntry(bc, x[i])
+    }
+}
+
+function read9(bc: bare.ByteCursor): readonly Schedule[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readSchedule(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readSchedule(bc)
+    }
+    return result
+}
+
+function write9(bc: bare.ByteCursor, x: readonly Schedule[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeSchedule(bc, x[i])
+    }
+}
+
+export type Init = {
+    readonly connections: readonly Connection[]
+    readonly state: State | null
+    readonly isStateEnabled: boolean
+    readonly rpcs: readonly string[]
+    readonly isDatabaseEnabled: boolean
+    readonly queueSize: uint
+    readonly workflowHistory: WorkflowHistory | null
+    readonly isWorkflowEnabled: boolean
+    readonly tabConfig: readonly TabConfigEntry[]
+    readonly schedules: readonly Schedule[]
+}
+
+export function readInit(bc: bare.ByteCursor): Init {
+    return {
+        connections: read4(bc),
+        state: read5(bc),
+        isStateEnabled: bare.readBool(bc),
+        rpcs: read6(bc),
+        isDatabaseEnabled: bare.readBool(bc),
+        queueSize: bare.readUint(bc),
+        workflowHistory: read7(bc),
+        isWorkflowEnabled: bare.readBool(bc),
+        tabConfig: read8(bc),
+        schedules: read9(bc),
+    }
+}
+
+export function writeInit(bc: bare.ByteCursor, x: Init): void {
+    write4(bc, x.connections)
+    write5(bc, x.state)
+    bare.writeBool(bc, x.isStateEnabled)
+    write6(bc, x.rpcs)
+    bare.writeBool(bc, x.isDatabaseEnabled)
+    bare.writeUint(bc, x.queueSize)
+    write7(bc, x.workflowHistory)
+    bare.writeBool(bc, x.isWorkflowEnabled)
+    write8(bc, x.tabConfig)
+    write9(bc, x.schedules)
+}
+
+export type ConnectionsResponse = {
+    readonly rid: uint
+    readonly connections: readonly Connection[]
+}
+
+export function readConnectionsResponse(bc: bare.ByteCursor): ConnectionsResponse {
+    return {
+        rid: bare.readUint(bc),
+        connections: read4(bc),
+    }
+}
+
+export function writeConnectionsResponse(bc: bare.ByteCursor, x: ConnectionsResponse): void {
+    bare.writeUint(bc, x.rid)
+    write4(bc, x.connections)
+}
+
+export type StateResponse = {
+    readonly rid: uint
+    readonly state: State | null
+    readonly isStateEnabled: boolean
+}
+
+export function readStateResponse(bc: bare.ByteCursor): StateResponse {
+    return {
+        rid: bare.readUint(bc),
+        state: read5(bc),
+        isStateEnabled: bare.readBool(bc),
+    }
+}
+
+export function writeStateResponse(bc: bare.ByteCursor, x: StateResponse): void {
+    bare.writeUint(bc, x.rid)
+    write5(bc, x.state)
+    bare.writeBool(bc, x.isStateEnabled)
+}
+
+export type ActionResponse = {
+    readonly rid: uint
+    readonly output: ArrayBuffer
+}
+
+export function readActionResponse(bc: bare.ByteCursor): ActionResponse {
+    return {
+        rid: bare.readUint(bc),
+        output: bare.readData(bc),
+    }
+}
+
+export function writeActionResponse(bc: bare.ByteCursor, x: ActionResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeData(bc, x.output)
+}
+
+export type TraceQueryResponse = {
+    readonly rid: uint
+    readonly payload: ArrayBuffer
+}
+
+export function readTraceQueryResponse(bc: bare.ByteCursor): TraceQueryResponse {
+    return {
+        rid: bare.readUint(bc),
+        payload: bare.readData(bc),
+    }
+}
+
+export function writeTraceQueryResponse(bc: bare.ByteCursor, x: TraceQueryResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeData(bc, x.payload)
+}
+
+export type QueueMessageSummary = {
+    readonly id: uint
+    readonly name: string
+    readonly createdAtMs: uint
+}
+
+export function readQueueMessageSummary(bc: bare.ByteCursor): QueueMessageSummary {
+    return {
+        id: bare.readUint(bc),
+        name: bare.readString(bc),
+        createdAtMs: bare.readUint(bc),
+    }
+}
+
+export function writeQueueMessageSummary(bc: bare.ByteCursor, x: QueueMessageSummary): void {
+    bare.writeUint(bc, x.id)
+    bare.writeString(bc, x.name)
+    bare.writeUint(bc, x.createdAtMs)
+}
+
+function read10(bc: bare.ByteCursor): readonly QueueMessageSummary[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readQueueMessageSummary(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readQueueMessageSummary(bc)
+    }
+    return result
+}
+
+function write10(bc: bare.ByteCursor, x: readonly QueueMessageSummary[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeQueueMessageSummary(bc, x[i])
+    }
+}
+
+export type QueueStatus = {
+    readonly size: uint
+    readonly maxSize: uint
+    readonly messages: readonly QueueMessageSummary[]
+    readonly truncated: boolean
+}
+
+export function readQueueStatus(bc: bare.ByteCursor): QueueStatus {
+    return {
+        size: bare.readUint(bc),
+        maxSize: bare.readUint(bc),
+        messages: read10(bc),
+        truncated: bare.readBool(bc),
+    }
+}
+
+export function writeQueueStatus(bc: bare.ByteCursor, x: QueueStatus): void {
+    bare.writeUint(bc, x.size)
+    bare.writeUint(bc, x.maxSize)
+    write10(bc, x.messages)
+    bare.writeBool(bc, x.truncated)
+}
+
+export type QueueResponse = {
+    readonly rid: uint
+    readonly status: QueueStatus
+}
+
+export function readQueueResponse(bc: bare.ByteCursor): QueueResponse {
+    return {
+        rid: bare.readUint(bc),
+        status: readQueueStatus(bc),
+    }
+}
+
+export function writeQueueResponse(bc: bare.ByteCursor, x: QueueResponse): void {
+    bare.writeUint(bc, x.rid)
+    writeQueueStatus(bc, x.status)
+}
+
+export type WorkflowHistoryResponse = {
+    readonly rid: uint
+    readonly history: WorkflowHistory | null
+    readonly isWorkflowEnabled: boolean
+}
+
+export function readWorkflowHistoryResponse(bc: bare.ByteCursor): WorkflowHistoryResponse {
+    return {
+        rid: bare.readUint(bc),
+        history: read7(bc),
+        isWorkflowEnabled: bare.readBool(bc),
+    }
+}
+
+export function writeWorkflowHistoryResponse(bc: bare.ByteCursor, x: WorkflowHistoryResponse): void {
+    bare.writeUint(bc, x.rid)
+    write7(bc, x.history)
+    bare.writeBool(bc, x.isWorkflowEnabled)
+}
+
+export type WorkflowReplayResponse = {
+    readonly rid: uint
+    readonly history: WorkflowHistory | null
+    readonly isWorkflowEnabled: boolean
+}
+
+export function readWorkflowReplayResponse(bc: bare.ByteCursor): WorkflowReplayResponse {
+    return {
+        rid: bare.readUint(bc),
+        history: read7(bc),
+        isWorkflowEnabled: bare.readBool(bc),
+    }
+}
+
+export function writeWorkflowReplayResponse(bc: bare.ByteCursor, x: WorkflowReplayResponse): void {
+    bare.writeUint(bc, x.rid)
+    write7(bc, x.history)
+    bare.writeBool(bc, x.isWorkflowEnabled)
+}
+
+export type DatabaseSchemaResponse = {
+    readonly rid: uint
+    readonly schema: ArrayBuffer
+}
+
+export function readDatabaseSchemaResponse(bc: bare.ByteCursor): DatabaseSchemaResponse {
+    return {
+        rid: bare.readUint(bc),
+        schema: bare.readData(bc),
+    }
+}
+
+export function writeDatabaseSchemaResponse(bc: bare.ByteCursor, x: DatabaseSchemaResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeData(bc, x.schema)
+}
+
+export type DatabaseTableRowsResponse = {
+    readonly rid: uint
+    readonly result: ArrayBuffer
+}
+
+export function readDatabaseTableRowsResponse(bc: bare.ByteCursor): DatabaseTableRowsResponse {
+    return {
+        rid: bare.readUint(bc),
+        result: bare.readData(bc),
+    }
+}
+
+export function writeDatabaseTableRowsResponse(bc: bare.ByteCursor, x: DatabaseTableRowsResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeData(bc, x.result)
+}
+
+export type SchedulesResponse = {
+    readonly rid: uint
+    readonly schedules: readonly Schedule[]
+}
+
+export function readSchedulesResponse(bc: bare.ByteCursor): SchedulesResponse {
+    return {
+        rid: bare.readUint(bc),
+        schedules: read9(bc),
+    }
+}
+
+export function writeSchedulesResponse(bc: bare.ByteCursor, x: SchedulesResponse): void {
+    bare.writeUint(bc, x.rid)
+    write9(bc, x.schedules)
+}
+
+function read11(bc: bare.ByteCursor): readonly ScheduleFire[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readScheduleFire(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readScheduleFire(bc)
+    }
+    return result
+}
+
+function write11(bc: bare.ByteCursor, x: readonly ScheduleFire[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeScheduleFire(bc, x[i])
+    }
+}
+
+export type ScheduleHistoryResponse = {
+    readonly rid: uint
+    readonly scheduleId: string
+    readonly history: readonly ScheduleFire[]
+}
+
+export function readScheduleHistoryResponse(bc: bare.ByteCursor): ScheduleHistoryResponse {
+    return {
+        rid: bare.readUint(bc),
+        scheduleId: bare.readString(bc),
+        history: read11(bc),
+    }
+}
+
+export function writeScheduleHistoryResponse(bc: bare.ByteCursor, x: ScheduleHistoryResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeString(bc, x.scheduleId)
+    write11(bc, x.history)
+}
+
+export type ScheduleDeleteResponse = {
+    readonly rid: uint
+    readonly scheduleId: string
+    readonly deleted: boolean
+}
+
+export function readScheduleDeleteResponse(bc: bare.ByteCursor): ScheduleDeleteResponse {
+    return {
+        rid: bare.readUint(bc),
+        scheduleId: bare.readString(bc),
+        deleted: bare.readBool(bc),
+    }
+}
+
+export function writeScheduleDeleteResponse(bc: bare.ByteCursor, x: ScheduleDeleteResponse): void {
+    bare.writeUint(bc, x.rid)
+    bare.writeString(bc, x.scheduleId)
+    bare.writeBool(bc, x.deleted)
+}
+
+export type StateUpdated = {
+    readonly state: State
+}
+
+export function readStateUpdated(bc: bare.ByteCursor): StateUpdated {
+    return {
+        state: readState(bc),
+    }
+}
+
+export function writeStateUpdated(bc: bare.ByteCursor, x: StateUpdated): void {
+    writeState(bc, x.state)
+}
+
+export type QueueUpdated = {
+    readonly queueSize: uint
+}
+
+export function readQueueUpdated(bc: bare.ByteCursor): QueueUpdated {
+    return {
+        queueSize: bare.readUint(bc),
+    }
+}
+
+export function writeQueueUpdated(bc: bare.ByteCursor, x: QueueUpdated): void {
+    bare.writeUint(bc, x.queueSize)
+}
+
+export type WorkflowHistoryUpdated = {
+    readonly history: WorkflowHistory
+}
+
+export function readWorkflowHistoryUpdated(bc: bare.ByteCursor): WorkflowHistoryUpdated {
+    return {
+        history: readWorkflowHistory(bc),
+    }
+}
+
+export function writeWorkflowHistoryUpdated(bc: bare.ByteCursor, x: WorkflowHistoryUpdated): void {
+    writeWorkflowHistory(bc, x.history)
+}
+
+export type SchedulesUpdated = {
+    readonly schedules: readonly Schedule[]
+}
+
+export function readSchedulesUpdated(bc: bare.ByteCursor): SchedulesUpdated {
+    return {
+        schedules: read9(bc),
+    }
+}
+
+export function writeSchedulesUpdated(bc: bare.ByteCursor, x: SchedulesUpdated): void {
+    write9(bc, x.schedules)
+}
+
+export type RpcsListResponse = {
+    readonly rid: uint
+    readonly rpcs: readonly string[]
+}
+
+export function readRpcsListResponse(bc: bare.ByteCursor): RpcsListResponse {
+    return {
+        rid: bare.readUint(bc),
+        rpcs: read6(bc),
+    }
+}
+
+export function writeRpcsListResponse(bc: bare.ByteCursor, x: RpcsListResponse): void {
+    bare.writeUint(bc, x.rid)
+    write6(bc, x.rpcs)
+}
+
+export type ConnectionsUpdated = {
+    readonly connections: readonly Connection[]
+}
+
+export function readConnectionsUpdated(bc: bare.ByteCursor): ConnectionsUpdated {
+    return {
+        connections: read4(bc),
+    }
+}
+
+export function writeConnectionsUpdated(bc: bare.ByteCursor, x: ConnectionsUpdated): void {
+    write4(bc, x.connections)
+}
+
+export type Error = {
+    readonly message: string
+}
+
+export function readError(bc: bare.ByteCursor): Error {
+    return {
+        message: bare.readString(bc),
+    }
+}
+
+export function writeError(bc: bare.ByteCursor, x: Error): void {
+    bare.writeString(bc, x.message)
+}
+
+export type ToClientBody =
+    | { readonly tag: "StateResponse"; readonly val: StateResponse }
+    | { readonly tag: "ConnectionsResponse"; readonly val: ConnectionsResponse }
+    | { readonly tag: "ActionResponse"; readonly val: ActionResponse }
+    | { readonly tag: "ConnectionsUpdated"; readonly val: ConnectionsUpdated }
+    | { readonly tag: "QueueUpdated"; readonly val: QueueUpdated }
+    | { readonly tag: "StateUpdated"; readonly val: StateUpdated }
+    | { readonly tag: "WorkflowHistoryUpdated"; readonly val: WorkflowHistoryUpdated }
+    | { readonly tag: "SchedulesUpdated"; readonly val: SchedulesUpdated }
+    | { readonly tag: "RpcsListResponse"; readonly val: RpcsListResponse }
+    | { readonly tag: "TraceQueryResponse"; readonly val: TraceQueryResponse }
+    | { readonly tag: "QueueResponse"; readonly val: QueueResponse }
+    | { readonly tag: "WorkflowHistoryResponse"; readonly val: WorkflowHistoryResponse }
+    | { readonly tag: "WorkflowReplayResponse"; readonly val: WorkflowReplayResponse }
+    | { readonly tag: "SchedulesResponse"; readonly val: SchedulesResponse }
+    | { readonly tag: "ScheduleHistoryResponse"; readonly val: ScheduleHistoryResponse }
+    | { readonly tag: "ScheduleDeleteResponse"; readonly val: ScheduleDeleteResponse }
+    | { readonly tag: "Error"; readonly val: Error }
+    | { readonly tag: "Init"; readonly val: Init }
+    | { readonly tag: "DatabaseSchemaResponse"; readonly val: DatabaseSchemaResponse }
+    | { readonly tag: "DatabaseTableRowsResponse"; readonly val: DatabaseTableRowsResponse }
+
+export function readToClientBody(bc: bare.ByteCursor): ToClientBody {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "StateResponse", val: readStateResponse(bc) }
+        case 1:
+            return { tag: "ConnectionsResponse", val: readConnectionsResponse(bc) }
+        case 2:
+            return { tag: "ActionResponse", val: readActionResponse(bc) }
+        case 3:
+            return { tag: "ConnectionsUpdated", val: readConnectionsUpdated(bc) }
+        case 4:
+            return { tag: "QueueUpdated", val: readQueueUpdated(bc) }
+        case 5:
+            return { tag: "StateUpdated", val: readStateUpdated(bc) }
+        case 6:
+            return { tag: "WorkflowHistoryUpdated", val: readWorkflowHistoryUpdated(bc) }
+        case 7:
+            return { tag: "SchedulesUpdated", val: readSchedulesUpdated(bc) }
+        case 8:
+            return { tag: "RpcsListResponse", val: readRpcsListResponse(bc) }
+        case 9:
+            return { tag: "TraceQueryResponse", val: readTraceQueryResponse(bc) }
+        case 10:
+            return { tag: "QueueResponse", val: readQueueResponse(bc) }
+        case 11:
+            return { tag: "WorkflowHistoryResponse", val: readWorkflowHistoryResponse(bc) }
+        case 12:
+            return { tag: "WorkflowReplayResponse", val: readWorkflowReplayResponse(bc) }
+        case 13:
+            return { tag: "SchedulesResponse", val: readSchedulesResponse(bc) }
+        case 14:
+            return { tag: "ScheduleHistoryResponse", val: readScheduleHistoryResponse(bc) }
+        case 15:
+            return { tag: "ScheduleDeleteResponse", val: readScheduleDeleteResponse(bc) }
+        case 16:
+            return { tag: "Error", val: readError(bc) }
+        case 17:
+            return { tag: "Init", val: readInit(bc) }
+        case 18:
+            return { tag: "DatabaseSchemaResponse", val: readDatabaseSchemaResponse(bc) }
+        case 19:
+            return { tag: "DatabaseTableRowsResponse", val: readDatabaseTableRowsResponse(bc) }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeToClientBody(bc: bare.ByteCursor, x: ToClientBody): void {
+    switch (x.tag) {
+        case "StateResponse": {
+            bare.writeU8(bc, 0)
+            writeStateResponse(bc, x.val)
+            break
+        }
+        case "ConnectionsResponse": {
+            bare.writeU8(bc, 1)
+            writeConnectionsResponse(bc, x.val)
+            break
+        }
+        case "ActionResponse": {
+            bare.writeU8(bc, 2)
+            writeActionResponse(bc, x.val)
+            break
+        }
+        case "ConnectionsUpdated": {
+            bare.writeU8(bc, 3)
+            writeConnectionsUpdated(bc, x.val)
+            break
+        }
+        case "QueueUpdated": {
+            bare.writeU8(bc, 4)
+            writeQueueUpdated(bc, x.val)
+            break
+        }
+        case "StateUpdated": {
+            bare.writeU8(bc, 5)
+            writeStateUpdated(bc, x.val)
+            break
+        }
+        case "WorkflowHistoryUpdated": {
+            bare.writeU8(bc, 6)
+            writeWorkflowHistoryUpdated(bc, x.val)
+            break
+        }
+        case "SchedulesUpdated": {
+            bare.writeU8(bc, 7)
+            writeSchedulesUpdated(bc, x.val)
+            break
+        }
+        case "RpcsListResponse": {
+            bare.writeU8(bc, 8)
+            writeRpcsListResponse(bc, x.val)
+            break
+        }
+        case "TraceQueryResponse": {
+            bare.writeU8(bc, 9)
+            writeTraceQueryResponse(bc, x.val)
+            break
+        }
+        case "QueueResponse": {
+            bare.writeU8(bc, 10)
+            writeQueueResponse(bc, x.val)
+            break
+        }
+        case "WorkflowHistoryResponse": {
+            bare.writeU8(bc, 11)
+            writeWorkflowHistoryResponse(bc, x.val)
+            break
+        }
+        case "WorkflowReplayResponse": {
+            bare.writeU8(bc, 12)
+            writeWorkflowReplayResponse(bc, x.val)
+            break
+        }
+        case "SchedulesResponse": {
+            bare.writeU8(bc, 13)
+            writeSchedulesResponse(bc, x.val)
+            break
+        }
+        case "ScheduleHistoryResponse": {
+            bare.writeU8(bc, 14)
+            writeScheduleHistoryResponse(bc, x.val)
+            break
+        }
+        case "ScheduleDeleteResponse": {
+            bare.writeU8(bc, 15)
+            writeScheduleDeleteResponse(bc, x.val)
+            break
+        }
+        case "Error": {
+            bare.writeU8(bc, 16)
+            writeError(bc, x.val)
+            break
+        }
+        case "Init": {
+            bare.writeU8(bc, 17)
+            writeInit(bc, x.val)
+            break
+        }
+        case "DatabaseSchemaResponse": {
+            bare.writeU8(bc, 18)
+            writeDatabaseSchemaResponse(bc, x.val)
+            break
+        }
+        case "DatabaseTableRowsResponse": {
+            bare.writeU8(bc, 19)
+            writeDatabaseTableRowsResponse(bc, x.val)
+            break
+        }
+    }
+}
+
+export type ToClient = {
+    readonly body: ToClientBody
+}
+
+export function readToClient(bc: bare.ByteCursor): ToClient {
+    return {
+        body: readToClientBody(bc),
+    }
+}
+
+export function writeToClient(bc: bare.ByteCursor, x: ToClient): void {
+    writeToClientBody(bc, x.body)
+}
+
+export function encodeToClient(x: ToClient, config?: Partial<bare.Config>): Uint8Array {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG
+    const bc = new bare.ByteCursor(
+        new Uint8Array(fullConfig.initialBufferLength),
+        fullConfig,
+    )
+    writeToClient(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeToClient(bytes: Uint8Array): ToClient {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG)
+    const result = readToClient(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
+
+function assert(condition: boolean, message?: string): asserts condition {
+    if (!condition) throw new Error(message ?? "Assertion failed")
+}