rivetkit 2.0.2 → 2.0.4-rc.1

package/dist/tsup/utils-fwx3o3K9.d.ts

@@ -0,0 +1,18 @@
+import { Next } from 'hono';
+import { ContentfulStatusCode } from 'hono/utils/http-status';
+
+declare function assertUnreachable(x: never): never;
+interface DeconstructedError {
+    __type: "ActorError";
+    statusCode: ContentfulStatusCode;
+    public: boolean;
+    group: string;
+    code: string;
+    message: string;
+    metadata?: unknown;
+}
+declare function stringifyError(error: unknown): string;
+/** Generates a `Next` handler to pass to middleware in order to be able to call arbitrary middleware. */
+declare function noopNext(): Next;
+
+export { type DeconstructedError as D, assertUnreachable as a, noopNext as n, stringifyError as s };

package/dist/tsup/utils.cjs

@@ -0,0 +1,43 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkPQZHDKRWcjs = require('./chunk-PQZHDKRW.cjs');
+require('./chunk-L47L3ZWJ.cjs');
+require('./chunk-HDQ2JUQT.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.EXTRA_ERROR_LOG = _chunkPQZHDKRWcjs.EXTRA_ERROR_LOG; exports.SinglePromiseQueue = _chunkPQZHDKRWcjs.SinglePromiseQueue; exports.VERSION = _chunkPQZHDKRWcjs.VERSION; exports.arrayBuffersEqual = _chunkPQZHDKRWcjs.arrayBuffersEqual; exports.assertUnreachable = _chunkPQZHDKRWcjs.assertUnreachable; exports.bufferToArrayBuffer = _chunkPQZHDKRWcjs.bufferToArrayBuffer; exports.combineUrlPath = _chunkPQZHDKRWcjs.combineUrlPath; exports.dbg = _chunkPQZHDKRWcjs.dbg; exports.detectRuntime = _chunkPQZHDKRWcjs.detectRuntime; exports.getEnvUniversal = _chunkPQZHDKRWcjs.getEnvUniversal; exports.httpUserAgent = _chunkPQZHDKRWcjs.httpUserAgent; exports.interval = _chunkPQZHDKRWcjs.interval; exports.joinSignals = _chunkPQZHDKRWcjs.joinSignals; exports.promiseWithResolvers = _chunkPQZHDKRWcjs.promiseWithResolvers; exports.setLongTimeout = _chunkPQZHDKRWcjs.setLongTimeout; exports.sleep = _chunkPQZHDKRWcjs.sleep; exports.stringifyError = _chunkPQZHDKRWcjs.stringifyError; exports.toUint8Array = _chunkPQZHDKRWcjs.toUint8Array;
+//# sourceMappingURL=utils.cjs.map

package/dist/tsup/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/rivet/rivet/rivetkit-typescript/packages/rivetkit/dist/tsup/utils.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,mgCAAC","file":"/home/runner/work/rivet/rivet/rivetkit-typescript/packages/rivetkit/dist/tsup/utils.cjs"}

package/dist/tsup/utils.d.cts

@@ -0,0 +1,148 @@
+export { a as assertUnreachable, s as stringifyError } from './utils-fwx3o3K9.cjs';
+import { Context, Handler } from 'hono';
+import 'hono/utils/http-status';
+
+/**
+ * Joins multiple abort signals into one.
+ *
+ * The returned signal aborts when the first input signal aborts.
+ * Uses `AbortSignal.any(...)` when available, with a runtime fallback.
+ *
+ * @experimental
+ */
+declare function joinSignals(...signals: Array<AbortSignal | undefined | null>): AbortSignal;
+/**
+ * Returns a promise that resolves after the given number of milliseconds.
+ *
+ * @experimental
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Creates a fixed-rate interval tick function that can be awaited in a loop.
+ *
+ * @example
+ * const tick = interval(100);
+ * while (!c.aborted) {
+ *   await tick();
+ *   if (c.aborted) break;
+ *   // ... game logic
+ * }
+ *
+ * @experimental
+ */
+declare function interval(ms: number): () => Promise<void>;
+declare const VERSION: string;
+/**
+ * Builds the HTTP user agent used by this library.
+ *
+ * @experimental
+ */
+declare function httpUserAgent(): string;
+type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
+type GetUpgradeWebSocket = () => UpgradeWebSocket;
+/**
+ * Reads an environment variable from Deno or Node runtimes.
+ *
+ * @experimental
+ */
+declare function getEnvUniversal(key: string): string | undefined;
+/**
+ * Traces a debug value and returns it.
+ *
+ * @experimental
+ */
+declare function dbg<T>(x: T): T;
+/**
+ * Converts various ArrayBuffer-like types to Uint8Array.
+ * Handles ArrayBuffer, ArrayBufferView (including typed arrays), and passes through existing Uint8Array.
+ *
+ * @param data - The ArrayBuffer or ArrayBufferView to convert
+ * @returns A Uint8Array view of the data
+ *
+ * @experimental
+ */
+declare function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array;
+type LongTimeoutHandle = {
+    abort: () => void;
+};
+/**
+ * Polyfill for Promise.withResolvers().
+ *
+ * This is specifically for Cloudflare Workers. Their implementation of Promise.withResolvers does not work correctly.
+ *
+ * @experimental
+ */
+declare function promiseWithResolvers<T>(onReject: (reason?: any) => void): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+/**
+ * Sets a timeout that supports delays larger than the JavaScript timer limit.
+ *
+ * @experimental
+ */
+declare function setLongTimeout(listener: () => void, after: number): LongTimeoutHandle;
+/**
+ * A tiny utility that coalesces/enqueues async operations so only the latest
+ * queued task runs per cycle, while callers receive a promise that resolves
+ * when the task for the cycle they joined has completed.
+ */
+declare class SinglePromiseQueue {
+    #private;
+    /** The currently running promise of #drainLoop. Do not await this, instead await `pending` to await the current cycle. */
+    runningDrainLoop?: Promise<void>;
+    /** Queue the next operation and return a promise that resolves when it flushes. */
+    enqueue(op: () => Promise<void>): Promise<void>;
+}
+/**
+ * Converts a Buffer or Uint8Array into an ArrayBuffer view.
+ *
+ * @experimental
+ */
+declare function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer;
+/**
+ * Properly combines a base URL endpoint with a path, preserving any base path in the endpoint.
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors/action")
+ * // Returns: "http://localhost:8787/rivet/actors/action"
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors?type=foo", { namespace: "test" })
+ * // Returns: "http://localhost:8787/rivet/actors?type=foo&namespace=test"
+ *
+ * @param endpoint The base URL endpoint that may contain a path component
+ * @param path The path to append to the endpoint (may include query parameters)
+ * @param queryParams Optional additional query parameters to append
+ * @returns The properly combined URL string
+ *
+ * @experimental
+ */
+declare function combineUrlPath(endpoint: string, path: string, queryParams?: Record<string, string | undefined>): string;
+/**
+ * Compares two ArrayBuffer values by byte content.
+ *
+ * @experimental
+ */
+declare function arrayBuffersEqual(buf1: ArrayBuffer, buf2: ArrayBuffer): boolean;
+declare const EXTRA_ERROR_LOG: {
+    issues: string;
+    support: string;
+    version: string;
+};
+type Runtime = "deno" | "bun" | "node";
+/**
+ * Detects the current JavaScript runtime from the user agent.
+ *
+ * @experimental
+ */
+declare function detectRuntime(): Runtime;
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
+};
+type DeepMutable<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? DeepMutable<T[K]> : T[K];
+};
+
+export { type DeepMutable, type DeepReadonly, EXTRA_ERROR_LOG, type GetUpgradeWebSocket, type LongTimeoutHandle, type Runtime, SinglePromiseQueue, type UpgradeWebSocket, VERSION, arrayBuffersEqual, bufferToArrayBuffer, combineUrlPath, dbg, detectRuntime, getEnvUniversal, httpUserAgent, interval, joinSignals, promiseWithResolvers, setLongTimeout, sleep, toUint8Array };

package/dist/tsup/utils.d.ts

@@ -0,0 +1,148 @@
+export { a as assertUnreachable, s as stringifyError } from './utils-fwx3o3K9.js';
+import { Context, Handler } from 'hono';
+import 'hono/utils/http-status';
+
+/**
+ * Joins multiple abort signals into one.
+ *
+ * The returned signal aborts when the first input signal aborts.
+ * Uses `AbortSignal.any(...)` when available, with a runtime fallback.
+ *
+ * @experimental
+ */
+declare function joinSignals(...signals: Array<AbortSignal | undefined | null>): AbortSignal;
+/**
+ * Returns a promise that resolves after the given number of milliseconds.
+ *
+ * @experimental
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Creates a fixed-rate interval tick function that can be awaited in a loop.
+ *
+ * @example
+ * const tick = interval(100);
+ * while (!c.aborted) {
+ *   await tick();
+ *   if (c.aborted) break;
+ *   // ... game logic
+ * }
+ *
+ * @experimental
+ */
+declare function interval(ms: number): () => Promise<void>;
+declare const VERSION: string;
+/**
+ * Builds the HTTP user agent used by this library.
+ *
+ * @experimental
+ */
+declare function httpUserAgent(): string;
+type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
+type GetUpgradeWebSocket = () => UpgradeWebSocket;
+/**
+ * Reads an environment variable from Deno or Node runtimes.
+ *
+ * @experimental
+ */
+declare function getEnvUniversal(key: string): string | undefined;
+/**
+ * Traces a debug value and returns it.
+ *
+ * @experimental
+ */
+declare function dbg<T>(x: T): T;
+/**
+ * Converts various ArrayBuffer-like types to Uint8Array.
+ * Handles ArrayBuffer, ArrayBufferView (including typed arrays), and passes through existing Uint8Array.
+ *
+ * @param data - The ArrayBuffer or ArrayBufferView to convert
+ * @returns A Uint8Array view of the data
+ *
+ * @experimental
+ */
+declare function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array;
+type LongTimeoutHandle = {
+    abort: () => void;
+};
+/**
+ * Polyfill for Promise.withResolvers().
+ *
+ * This is specifically for Cloudflare Workers. Their implementation of Promise.withResolvers does not work correctly.
+ *
+ * @experimental
+ */
+declare function promiseWithResolvers<T>(onReject: (reason?: any) => void): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+/**
+ * Sets a timeout that supports delays larger than the JavaScript timer limit.
+ *
+ * @experimental
+ */
+declare function setLongTimeout(listener: () => void, after: number): LongTimeoutHandle;
+/**
+ * A tiny utility that coalesces/enqueues async operations so only the latest
+ * queued task runs per cycle, while callers receive a promise that resolves
+ * when the task for the cycle they joined has completed.
+ */
+declare class SinglePromiseQueue {
+    #private;
+    /** The currently running promise of #drainLoop. Do not await this, instead await `pending` to await the current cycle. */
+    runningDrainLoop?: Promise<void>;
+    /** Queue the next operation and return a promise that resolves when it flushes. */
+    enqueue(op: () => Promise<void>): Promise<void>;
+}
+/**
+ * Converts a Buffer or Uint8Array into an ArrayBuffer view.
+ *
+ * @experimental
+ */
+declare function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer;
+/**
+ * Properly combines a base URL endpoint with a path, preserving any base path in the endpoint.
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors/action")
+ * // Returns: "http://localhost:8787/rivet/actors/action"
+ *
+ * @example
+ * combineUrlPath("http://localhost:8787/rivet", "/actors?type=foo", { namespace: "test" })
+ * // Returns: "http://localhost:8787/rivet/actors?type=foo&namespace=test"
+ *
+ * @param endpoint The base URL endpoint that may contain a path component
+ * @param path The path to append to the endpoint (may include query parameters)
+ * @param queryParams Optional additional query parameters to append
+ * @returns The properly combined URL string
+ *
+ * @experimental
+ */
+declare function combineUrlPath(endpoint: string, path: string, queryParams?: Record<string, string | undefined>): string;
+/**
+ * Compares two ArrayBuffer values by byte content.
+ *
+ * @experimental
+ */
+declare function arrayBuffersEqual(buf1: ArrayBuffer, buf2: ArrayBuffer): boolean;
+declare const EXTRA_ERROR_LOG: {
+    issues: string;
+    support: string;
+    version: string;
+};
+type Runtime = "deno" | "bun" | "node";
+/**
+ * Detects the current JavaScript runtime from the user agent.
+ *
+ * @experimental
+ */
+declare function detectRuntime(): Runtime;
+type DeepReadonly<T> = {
+    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
+};
+type DeepMutable<T> = {
+    -readonly [K in keyof T]: T[K] extends object ? DeepMutable<T[K]> : T[K];
+};
+
+export { type DeepMutable, type DeepReadonly, EXTRA_ERROR_LOG, type GetUpgradeWebSocket, type LongTimeoutHandle, type Runtime, SinglePromiseQueue, type UpgradeWebSocket, VERSION, arrayBuffersEqual, bufferToArrayBuffer, combineUrlPath, dbg, detectRuntime, getEnvUniversal, httpUserAgent, interval, joinSignals, promiseWithResolvers, setLongTimeout, sleep, toUint8Array };

package/dist/tsup/utils.js

@@ -0,0 +1,43 @@
+import {
+  EXTRA_ERROR_LOG,
+  SinglePromiseQueue,
+  VERSION,
+  arrayBuffersEqual,
+  assertUnreachable,
+  bufferToArrayBuffer,
+  combineUrlPath,
+  dbg,
+  detectRuntime,
+  getEnvUniversal,
+  httpUserAgent,
+  interval,
+  joinSignals,
+  promiseWithResolvers,
+  setLongTimeout,
+  sleep,
+  stringifyError,
+  toUint8Array
+} from "./chunk-325TLXJT.js";
+import "./chunk-7HTNH26M.js";
+import "./chunk-424PT5DM.js";
+export {
+  EXTRA_ERROR_LOG,
+  SinglePromiseQueue,
+  VERSION,
+  arrayBuffersEqual,
+  assertUnreachable,
+  bufferToArrayBuffer,
+  combineUrlPath,
+  dbg,
+  detectRuntime,
+  getEnvUniversal,
+  httpUserAgent,
+  interval,
+  joinSignals,
+  promiseWithResolvers,
+  setLongTimeout,
+  sleep,
+  stringifyError,
+  toUint8Array
+};
+//# sourceMappingURL=utils.js.map

package/dist/tsup/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/tsup/v3-DnYObHH3.d.cts

@@ -0,0 +1,279 @@
+import * as bare from '@rivetkit/bare-ts';
+
+type uint = bigint;
+type PatchStateRequest = {
+    readonly state: ArrayBuffer;
+};
+declare function readPatchStateRequest(bc: bare.ByteCursor): PatchStateRequest;
+declare function writePatchStateRequest(bc: bare.ByteCursor, x: PatchStateRequest): void;
+type ActionRequest = {
+    readonly id: uint;
+    readonly name: string;
+    readonly args: ArrayBuffer;
+};
+declare function readActionRequest(bc: bare.ByteCursor): ActionRequest;
+declare function writeActionRequest(bc: bare.ByteCursor, x: ActionRequest): void;
+type StateRequest = {
+    readonly id: uint;
+};
+declare function readStateRequest(bc: bare.ByteCursor): StateRequest;
+declare function writeStateRequest(bc: bare.ByteCursor, x: StateRequest): void;
+type ConnectionsRequest = {
+    readonly id: uint;
+};
+declare function readConnectionsRequest(bc: bare.ByteCursor): ConnectionsRequest;
+declare function writeConnectionsRequest(bc: bare.ByteCursor, x: ConnectionsRequest): void;
+type RpcsListRequest = {
+    readonly id: uint;
+};
+declare function readRpcsListRequest(bc: bare.ByteCursor): RpcsListRequest;
+declare function writeRpcsListRequest(bc: bare.ByteCursor, x: RpcsListRequest): void;
+type TraceQueryRequest = {
+    readonly id: uint;
+    readonly startMs: uint;
+    readonly endMs: uint;
+    readonly limit: uint;
+};
+declare function readTraceQueryRequest(bc: bare.ByteCursor): TraceQueryRequest;
+declare function writeTraceQueryRequest(bc: bare.ByteCursor, x: TraceQueryRequest): void;
+type QueueRequest = {
+    readonly id: uint;
+    readonly limit: uint;
+};
+declare function readQueueRequest(bc: bare.ByteCursor): QueueRequest;
+declare function writeQueueRequest(bc: bare.ByteCursor, x: QueueRequest): void;
+type WorkflowHistoryRequest = {
+    readonly id: uint;
+};
+declare function readWorkflowHistoryRequest(bc: bare.ByteCursor): WorkflowHistoryRequest;
+declare function writeWorkflowHistoryRequest(bc: bare.ByteCursor, x: WorkflowHistoryRequest): void;
+type DatabaseSchemaRequest = {
+    readonly id: uint;
+};
+declare function readDatabaseSchemaRequest(bc: bare.ByteCursor): DatabaseSchemaRequest;
+declare function writeDatabaseSchemaRequest(bc: bare.ByteCursor, x: DatabaseSchemaRequest): void;
+type DatabaseTableRowsRequest = {
+    readonly id: uint;
+    readonly table: string;
+    readonly limit: uint;
+    readonly offset: uint;
+};
+declare function readDatabaseTableRowsRequest(bc: bare.ByteCursor): DatabaseTableRowsRequest;
+declare function writeDatabaseTableRowsRequest(bc: bare.ByteCursor, x: DatabaseTableRowsRequest): void;
+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: "DatabaseSchemaRequest";
+    readonly val: DatabaseSchemaRequest;
+} | {
+    readonly tag: "DatabaseTableRowsRequest";
+    readonly val: DatabaseTableRowsRequest;
+};
+declare function readToServerBody(bc: bare.ByteCursor): ToServerBody;
+declare function writeToServerBody(bc: bare.ByteCursor, x: ToServerBody): void;
+type ToServer = {
+    readonly body: ToServerBody;
+};
+declare function readToServer(bc: bare.ByteCursor): ToServer;
+declare function writeToServer(bc: bare.ByteCursor, x: ToServer): void;
+declare function encodeToServer(x: ToServer): Uint8Array;
+declare function decodeToServer(bytes: Uint8Array): ToServer;
+type State = ArrayBuffer;
+declare function readState(bc: bare.ByteCursor): State;
+declare function writeState(bc: bare.ByteCursor, x: State): void;
+type Connection = {
+    readonly id: string;
+    readonly details: ArrayBuffer;
+};
+declare function readConnection(bc: bare.ByteCursor): Connection;
+declare function writeConnection(bc: bare.ByteCursor, x: Connection): void;
+type WorkflowHistory = ArrayBuffer;
+declare function readWorkflowHistory(bc: bare.ByteCursor): WorkflowHistory;
+declare function writeWorkflowHistory(bc: bare.ByteCursor, x: WorkflowHistory): void;
+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;
+};
+declare function readInit(bc: bare.ByteCursor): Init;
+declare function writeInit(bc: bare.ByteCursor, x: Init): void;
+type ConnectionsResponse = {
+    readonly rid: uint;
+    readonly connections: readonly Connection[];
+};
+declare function readConnectionsResponse(bc: bare.ByteCursor): ConnectionsResponse;
+declare function writeConnectionsResponse(bc: bare.ByteCursor, x: ConnectionsResponse): void;
+type StateResponse = {
+    readonly rid: uint;
+    readonly state: State | null;
+    readonly isStateEnabled: boolean;
+};
+declare function readStateResponse(bc: bare.ByteCursor): StateResponse;
+declare function writeStateResponse(bc: bare.ByteCursor, x: StateResponse): void;
+type ActionResponse = {
+    readonly rid: uint;
+    readonly output: ArrayBuffer;
+};
+declare function readActionResponse(bc: bare.ByteCursor): ActionResponse;
+declare function writeActionResponse(bc: bare.ByteCursor, x: ActionResponse): void;
+type TraceQueryResponse = {
+    readonly rid: uint;
+    readonly payload: ArrayBuffer;
+};
+declare function readTraceQueryResponse(bc: bare.ByteCursor): TraceQueryResponse;
+declare function writeTraceQueryResponse(bc: bare.ByteCursor, x: TraceQueryResponse): void;
+type QueueMessageSummary = {
+    readonly id: uint;
+    readonly name: string;
+    readonly createdAtMs: uint;
+};
+declare function readQueueMessageSummary(bc: bare.ByteCursor): QueueMessageSummary;
+declare function writeQueueMessageSummary(bc: bare.ByteCursor, x: QueueMessageSummary): void;
+type QueueStatus = {
+    readonly size: uint;
+    readonly maxSize: uint;
+    readonly messages: readonly QueueMessageSummary[];
+    readonly truncated: boolean;
+};
+declare function readQueueStatus(bc: bare.ByteCursor): QueueStatus;
+declare function writeQueueStatus(bc: bare.ByteCursor, x: QueueStatus): void;
+type QueueResponse = {
+    readonly rid: uint;
+    readonly status: QueueStatus;
+};
+declare function readQueueResponse(bc: bare.ByteCursor): QueueResponse;
+declare function writeQueueResponse(bc: bare.ByteCursor, x: QueueResponse): void;
+type WorkflowHistoryResponse = {
+    readonly rid: uint;
+    readonly history: WorkflowHistory | null;
+    readonly isWorkflowEnabled: boolean;
+};
+declare function readWorkflowHistoryResponse(bc: bare.ByteCursor): WorkflowHistoryResponse;
+declare function writeWorkflowHistoryResponse(bc: bare.ByteCursor, x: WorkflowHistoryResponse): void;
+type DatabaseSchemaResponse = {
+    readonly rid: uint;
+    readonly schema: ArrayBuffer;
+};
+declare function readDatabaseSchemaResponse(bc: bare.ByteCursor): DatabaseSchemaResponse;
+declare function writeDatabaseSchemaResponse(bc: bare.ByteCursor, x: DatabaseSchemaResponse): void;
+type DatabaseTableRowsResponse = {
+    readonly rid: uint;
+    readonly result: ArrayBuffer;
+};
+declare function readDatabaseTableRowsResponse(bc: bare.ByteCursor): DatabaseTableRowsResponse;
+declare function writeDatabaseTableRowsResponse(bc: bare.ByteCursor, x: DatabaseTableRowsResponse): void;
+type StateUpdated = {
+    readonly state: State;
+};
+declare function readStateUpdated(bc: bare.ByteCursor): StateUpdated;
+declare function writeStateUpdated(bc: bare.ByteCursor, x: StateUpdated): void;
+type QueueUpdated = {
+    readonly queueSize: uint;
+};
+declare function readQueueUpdated(bc: bare.ByteCursor): QueueUpdated;
+declare function writeQueueUpdated(bc: bare.ByteCursor, x: QueueUpdated): void;
+type WorkflowHistoryUpdated = {
+    readonly history: WorkflowHistory;
+};
+declare function readWorkflowHistoryUpdated(bc: bare.ByteCursor): WorkflowHistoryUpdated;
+declare function writeWorkflowHistoryUpdated(bc: bare.ByteCursor, x: WorkflowHistoryUpdated): void;
+type RpcsListResponse = {
+    readonly rid: uint;
+    readonly rpcs: readonly string[];
+};
+declare function readRpcsListResponse(bc: bare.ByteCursor): RpcsListResponse;
+declare function writeRpcsListResponse(bc: bare.ByteCursor, x: RpcsListResponse): void;
+type ConnectionsUpdated = {
+    readonly connections: readonly Connection[];
+};
+declare function readConnectionsUpdated(bc: bare.ByteCursor): ConnectionsUpdated;
+declare function writeConnectionsUpdated(bc: bare.ByteCursor, x: ConnectionsUpdated): void;
+type Error = {
+    readonly message: string;
+};
+declare function readError(bc: bare.ByteCursor): Error;
+declare function writeError(bc: bare.ByteCursor, x: Error): void;
+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: "RpcsListResponse";
+    readonly val: RpcsListResponse;
+} | {
+    readonly tag: "TraceQueryResponse";
+    readonly val: TraceQueryResponse;
+} | {
+    readonly tag: "QueueResponse";
+    readonly val: QueueResponse;
+} | {
+    readonly tag: "WorkflowHistoryResponse";
+    readonly val: WorkflowHistoryResponse;
+} | {
+    readonly tag: "Error";
+    readonly val: Error;
+} | {
+    readonly tag: "Init";
+    readonly val: Init;
+} | {
+    readonly tag: "DatabaseSchemaResponse";
+    readonly val: DatabaseSchemaResponse;
+} | {
+    readonly tag: "DatabaseTableRowsResponse";
+    readonly val: DatabaseTableRowsResponse;
+};
+declare function readToClientBody(bc: bare.ByteCursor): ToClientBody;
+declare function writeToClientBody(bc: bare.ByteCursor, x: ToClientBody): void;
+type ToClient = {
+    readonly body: ToClientBody;
+};
+declare function readToClient(bc: bare.ByteCursor): ToClient;
+declare function writeToClient(bc: bare.ByteCursor, x: ToClient): void;
+declare function encodeToClient(x: ToClient): Uint8Array;
+declare function decodeToClient(bytes: Uint8Array): ToClient;
+
+export { readQueueResponse as $, type ActionRequest as A, encodeToServer as B, type Connection as C, type DatabaseSchemaRequest as D, type Error as E, readActionRequest as F, readActionResponse as G, readConnection as H, type Init as I, readConnectionsRequest as J, readConnectionsResponse as K, readConnectionsUpdated as L, readDatabaseSchemaRequest as M, readDatabaseSchemaResponse as N, readDatabaseTableRowsRequest as O, type PatchStateRequest as P, type QueueMessageSummary as Q, type RpcsListRequest as R, type State as S, type ToClient as T, readDatabaseTableRowsResponse as U, readError as V, type WorkflowHistory as W, readInit as X, readPatchStateRequest as Y, readQueueMessageSummary as Z, readQueueRequest as _, type ToServer as a, readQueueStatus as a0, readQueueUpdated as a1, readRpcsListRequest as a2, readRpcsListResponse as a3, readState as a4, readStateRequest as a5, readStateResponse as a6, readStateUpdated as a7, readToClient as a8, readToClientBody as a9, writeQueueUpdated as aA, writeRpcsListRequest as aB, writeRpcsListResponse as aC, writeState as aD, writeStateRequest as aE, writeStateResponse as aF, writeStateUpdated as aG, writeToClient as aH, writeToClientBody as aI, writeToServer as aJ, writeToServerBody as aK, writeTraceQueryRequest as aL, writeTraceQueryResponse as aM, writeWorkflowHistory as aN, writeWorkflowHistoryRequest as aO, writeWorkflowHistoryResponse as aP, writeWorkflowHistoryUpdated as aQ, readToServer as aa, readToServerBody as ab, readTraceQueryRequest as ac, readTraceQueryResponse as ad, readWorkflowHistory as ae, readWorkflowHistoryRequest as af, readWorkflowHistoryResponse as ag, readWorkflowHistoryUpdated as ah, type uint as ai, writeActionRequest as aj, writeActionResponse as ak, writeConnection as al, writeConnectionsRequest as am, writeConnectionsResponse as an, writeConnectionsUpdated as ao, writeDatabaseSchemaRequest as ap, writeDatabaseSchemaResponse as aq, writeDatabaseTableRowsRequest as ar, writeDatabaseTableRowsResponse as as, writeError as at, writeInit as au, writePatchStateRequest as av, writeQueueMessageSummary as aw, writeQueueRequest as ax, writeQueueResponse as ay, writeQueueStatus as az, type ActionResponse as b, type ConnectionsRequest as c, type ConnectionsResponse as d, type ConnectionsUpdated as e, type DatabaseSchemaResponse as f, type DatabaseTableRowsRequest as g, type DatabaseTableRowsResponse as h, type QueueRequest as i, type QueueResponse as j, type QueueStatus as k, type QueueUpdated as l, type RpcsListResponse as m, type StateRequest as n, type StateResponse as o, type StateUpdated as p, type ToClientBody as q, type ToServerBody as r, type TraceQueryRequest as s, type TraceQueryResponse as t, type WorkflowHistoryRequest as u, type WorkflowHistoryResponse as v, type WorkflowHistoryUpdated as w, decodeToClient as x, decodeToServer as y, encodeToClient as z };