rivetkit 2.0.2 → 2.0.4-rc.1

package/dist/browser/client.d.ts

@@ -0,0 +1,2485 @@
+import z$2, { z } from 'zod/v4';
+import { UniversalWebSocket } from '@rivetkit/virtual-websocket';
+import { SqliteVfs } from '@rivetkit/sqlite-vfs';
+import { Traces, OtlpExportTraceServiceRequestJson, SpanHandle, SpanStatusInput } from '@rivetkit/traces';
+import { Context, Handler, Env, Hono } from 'hono';
+import { z as z$1 } from 'zod';
+import { Logger } from 'pino';
+import { VersionedDataHandler } from 'vbare';
+import { BaseSQLiteDatabase } from 'drizzle-orm/sqlite-core';
+import * as nanoevents from 'nanoevents';
+import { W as WorkflowHistory, k as QueueStatus } from './v3-DnYObHH3.js';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import '@rivetkit/bare-ts';
+
+type AnyDatabaseProvider = DatabaseProvider<any> | undefined;
+/**
+ * Context provided to database providers for creating database clients
+ */
+interface DatabaseProviderContext {
+    /**
+     * Actor ID
+     */
+    actorId: string;
+    /**
+     * Override the default raw database client (optional).
+     * If not provided, a KV-backed client will be constructed.
+     */
+    overrideRawDatabaseClient?: () => Promise<RawDatabaseClient | undefined>;
+    /**
+     * Override the default Drizzle database client (optional).
+     * If not provided, a KV-backed client will be constructed.
+     */
+    overrideDrizzleDatabaseClient?: () => Promise<DrizzleDatabaseClient | undefined>;
+    /**
+     * KV operations for constructing KV-backed database clients
+     */
+    kv: {
+        batchPut: (entries: [Uint8Array, Uint8Array][]) => Promise<void>;
+        batchGet: (keys: Uint8Array[]) => Promise<(Uint8Array | null)[]>;
+        batchDelete: (keys: Uint8Array[]) => Promise<void>;
+    };
+    /**
+     * SQLite VFS instance for creating KV-backed databases.
+     * This should be actor-scoped because @rivetkit/sqlite is not re-entrant per
+     * module instance.
+     */
+    sqliteVfs?: SqliteVfs;
+}
+type DatabaseProvider<DB extends RawAccess> = {
+    /**
+     * Creates a new database client for the actor.
+     * The result is passed to the actor context as `c.db`.
+     * @experimental
+     */
+    createClient: (ctx: DatabaseProviderContext) => Promise<DB>;
+    /**
+     * Runs before the actor has started.
+     * Use this to run migrations or other setup tasks.
+     * @experimental
+     */
+    onMigrate: (client: DB) => void | Promise<void>;
+    /**
+     * Runs when the actor is being destroyed.
+     * Use this to clean up database connections and release resources.
+     * @experimental
+     */
+    onDestroy?: (client: DB) => void | Promise<void>;
+};
+/**
+ * Raw database client with basic exec method
+ */
+interface RawDatabaseClient {
+    exec: <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]> | TRow[];
+}
+/**
+ * Drizzle database client interface (will be extended by drizzle-orm types)
+ */
+interface DrizzleDatabaseClient {
+}
+type ExecuteFunction = <TRow extends Record<string, unknown> = Record<string, unknown>>(query: string, ...args: unknown[]) => Promise<TRow[]>;
+type RawAccess = {
+    /**
+     * Executes a raw SQL query.
+     */
+    execute: ExecuteFunction;
+    /**
+     * Closes the database connection and releases resources.
+     */
+    close: () => Promise<void>;
+};
+
+type InferDatabaseClient<DBProvider extends AnyDatabaseProvider> = DBProvider extends DatabaseProvider<any> ? Awaited<ReturnType<DBProvider["createClient"]>> : never;
+
+type SchemaHookResult = boolean | Promise<boolean>;
+type SchemaHook<TContext = any> = (ctx: TContext) => SchemaHookResult;
+interface EventTypeToken<T, TContext = any> {
+    readonly _eventType?: T;
+    readonly canSubscribe?: SchemaHook<TContext>;
+    readonly schema?: PrimitiveSchema;
+}
+interface QueueTypeToken<TMessage, TComplete = never, TContext = any> {
+    readonly _queueMessage?: TMessage;
+    readonly _queueComplete?: TComplete;
+    readonly canPublish?: SchemaHook<TContext>;
+    readonly message?: PrimitiveSchema;
+    readonly complete?: PrimitiveSchema;
+}
+type PrimitiveSchema = StandardSchemaV1 | EventTypeToken<unknown, any>;
+interface EventSchemaDefinition<TContext = any> {
+    schema: PrimitiveSchema;
+    canSubscribe?: SchemaHook<TContext>;
+}
+interface QueueSchemaDefinition<TContext = any> {
+    message: PrimitiveSchema;
+    complete?: PrimitiveSchema;
+    canPublish?: SchemaHook<TContext>;
+}
+type EventSchema<TContext = any> = PrimitiveSchema | EventSchemaDefinition<TContext>;
+type QueueSchema = PrimitiveSchema | QueueSchemaDefinition<any> | QueueTypeToken<unknown, unknown, any>;
+type EventSchemaConfig<TContext = any> = Record<string, EventSchema<TContext>>;
+type QueueSchemaConfig<TContext = any> = Record<string, QueueSchema>;
+type InferSchema<T> = T extends QueueSchemaDefinition<any> ? InferSchema<T["message"]> : T extends QueueTypeToken<infer M, unknown, any> ? M : T extends EventSchemaDefinition<any> ? InferSchema<T["schema"]> : T extends StandardSchemaV1<any, infer O> ? O : T extends EventTypeToken<infer R, any> ? R : never;
+type InferSchemaMap<T extends Record<string, unknown>> = {
+    [K in keyof T]: InferSchema<T[K]>;
+};
+type InferQueueComplete<T> = T extends QueueTypeToken<unknown, infer C, any> ? [C] extends [never] ? never : C : T extends QueueSchemaDefinition<any> ? T["complete"] extends PrimitiveSchema ? InferSchema<T["complete"]> : never : never;
+type InferQueueCompleteMap<T extends QueueSchemaConfig> = {
+    [K in keyof T]: InferQueueComplete<T[K]>;
+};
+type InferEventArgs<T> = T extends readonly unknown[] ? number extends T["length"] ? [T] : T : [T];
+
+/**
+ * User-facing KV storage interface exposed on ActorContext.
+ */
+type KvValueType = "text" | "arrayBuffer" | "binary";
+type KvKeyType = "text" | "binary";
+type KvKey = Uint8Array | string;
+type KvValueTypeMap = {
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    binary: Uint8Array;
+};
+type KvKeyTypeMap = {
+    text: string;
+    binary: Uint8Array;
+};
+type KvValueOptions<T extends KvValueType = "text"> = {
+    type?: T;
+};
+type KvListOptions<T extends KvValueType = "text", K extends KvKeyType = "text"> = KvValueOptions<T> & {
+    keyType?: K;
+};
+declare class ActorKv {
+    #private;
+    constructor(driver: ActorDriver, actorId: string);
+    /**
+     * Get a single value by key.
+     */
+    get<T extends KvValueType = "text">(key: KvKey, options?: KvValueOptions<T>): Promise<KvValueTypeMap[T] | null>;
+    /**
+     * Get multiple values by keys.
+     */
+    getBatch<T extends KvValueType = "text">(keys: KvKey[], options?: KvValueOptions<T>): Promise<(KvValueTypeMap[T] | null)[]>;
+    /**
+     * Put a single key-value pair.
+     */
+    put<T extends KvValueType = KvValueType>(key: KvKey, value: KvValueTypeMap[T], options?: KvValueOptions<T>): Promise<void>;
+    /**
+     * Put multiple key-value pairs.
+     */
+    putBatch<T extends KvValueType = KvValueType>(entries: [KvKey, KvValueTypeMap[T]][], options?: KvValueOptions<T>): Promise<void>;
+    /**
+     * Delete a single key.
+     */
+    delete(key: KvKey): Promise<void>;
+    /**
+     * Delete multiple keys.
+     */
+    deleteBatch(keys: KvKey[]): Promise<void>;
+    /**
+     * List all keys with a given prefix.
+     * Returns key-value pairs where keys have the user prefix removed.
+     */
+    list<T extends KvValueType = "text", K extends KvKeyType = "text">(prefix: KvKeyTypeMap[K], options?: KvListOptions<T, K>): Promise<[KvKeyTypeMap[K], KvValueTypeMap[T]][]>;
+}
+
+interface QueueMessage {
+    id: bigint;
+    name: string;
+    body: unknown;
+    createdAt: number;
+}
+declare class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>, driver: ActorDriver);
+    /** Returns the current number of messages in the queue. */
+    get size(): number;
+    /** Loads queue metadata from storage and initializes internal state. */
+    initialize(): Promise<void>;
+    /** Adds a message to the queue with the given name and body. */
+    enqueue(name: string, body: unknown): Promise<QueueMessage>;
+    /**
+     * Adds a message and waits for completion.
+     */
+    enqueueAndWait(name: string, body: unknown, timeout?: number): Promise<{
+        status: "completed" | "timedOut";
+        response?: unknown;
+    }>;
+    completeMessage(message: QueueMessage, response?: unknown): Promise<void>;
+    completeMessageById(messageId: bigint, response?: unknown): Promise<void>;
+    /** Receives messages from the queue matching the given names. Waits until messages are available or timeout is reached. */
+    receive(names: string[] | undefined, count: number, timeout?: number, abortSignal?: AbortSignal, completable?: boolean): Promise<QueueMessage[]>;
+    waitForNames(names: readonly string[] | undefined, abortSignal?: AbortSignal): Promise<void>;
+    /** Returns all messages currently in the queue without removing them. */
+    getMessages(): Promise<QueueMessage[]>;
+    /** Deletes messages matching the provided IDs. Returns the IDs that were removed. */
+    deleteMessagesById(ids: bigint[]): Promise<bigint[]>;
+}
+
+type QueueMessageOf<Name extends string, Body> = Omit<QueueMessage, "name" | "body"> & {
+    name: Name;
+    body: Body;
+};
+type QueueName<TQueues extends QueueSchemaConfig> = keyof TQueues & string;
+type QueueFilterName<TQueues extends QueueSchemaConfig> = keyof TQueues extends never ? string : QueueName<TQueues>;
+type QueueMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = keyof TQueues extends never ? QueueMessage : TName extends QueueName<TQueues> ? QueueMessageOf<TName, InferSchemaMap<TQueues>[TName]> : never;
+type QueueCompleteArgs<T> = undefined extends T ? [response?: T] : [response: T];
+type QueueCompleteArgsForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = keyof TQueues extends never ? [response?: unknown] : TName extends QueueName<TQueues> ? [InferQueueCompleteMap<TQueues>[TName]] extends [never] ? [response?: unknown] : QueueCompleteArgs<InferQueueCompleteMap<TQueues>[TName]> : [response?: unknown];
+type QueueCompletableMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>> = QueueMessageForName<TQueues, TName> & {
+    complete(...args: QueueCompleteArgsForName<TQueues, TName>): Promise<void>;
+};
+type QueueResultMessageForName<TQueues extends QueueSchemaConfig, TName extends QueueFilterName<TQueues>, TCompletable extends boolean> = TCompletable extends true ? QueueCompletableMessageForName<TQueues, TName> : QueueMessageForName<TQueues, TName>;
+/** Options for receiving queue messages. */
+interface QueueNextOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Timeout in milliseconds. Omit to wait indefinitely. */
+    timeout?: number;
+    /** Optional abort signal for this receive call. */
+    signal?: AbortSignal;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for receiving queue message batches. */
+interface QueueNextBatchOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Maximum number of messages to receive. Defaults to 1. */
+    count?: number;
+    /** Timeout in milliseconds. Omit to wait indefinitely. */
+    timeout?: number;
+    /** Optional abort signal for this receive call. */
+    signal?: AbortSignal;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for non-blocking queue reads. */
+interface QueueTryNextOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for non-blocking queue batch reads. */
+interface QueueTryNextBatchOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Maximum number of messages to receive. Defaults to 1. */
+    count?: number;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** Options for queue async iteration. */
+interface QueueIterOptions<TName extends string = string, TCompletable extends boolean = boolean> {
+    /** Queue names to receive from. If omitted, reads from all queue names. */
+    names?: readonly TName[];
+    /** Optional abort signal for this iterator. */
+    signal?: AbortSignal;
+    /** Whether to return completable messages. */
+    completable?: TCompletable;
+}
+/** User-facing queue interface exposed on ActorContext. */
+declare class ActorQueue<S, CP, CS, V, I, DB extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(queueManager: QueueManager<S, CP, CS, V, I, DB, TEvents, TQueues>, abortSignal: AbortSignal);
+    next<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueNextOptions<TName, TCompletable>): Promise<QueueResultMessageForName<TQueues, TName, TCompletable> | undefined>;
+    nextBatch<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueNextBatchOptions<TName, TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, TName, TCompletable>>>;
+    tryNext<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueTryNextOptions<TName, TCompletable>): Promise<QueueResultMessageForName<TQueues, TName, TCompletable> | undefined>;
+    tryNextBatch<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueTryNextBatchOptions<TName, TCompletable>): Promise<Array<QueueResultMessageForName<TQueues, TName, TCompletable>>>;
+    iter<const TName extends QueueFilterName<TQueues>, const TCompletable extends boolean = false>(opts?: QueueIterOptions<TName, TCompletable>): AsyncIterableIterator<QueueResultMessageForName<TQueues, TName, TCompletable>>;
+    /** Sends a message to the specified queue. */
+    send<K extends keyof TQueues & string>(name: K, body: InferSchemaMap<TQueues>[K]): Promise<QueueMessage>;
+    send(name: keyof TQueues extends never ? string : never, body: unknown): Promise<QueueMessage>;
+}
+
+declare class Schedule {
+    #private;
+    constructor(actor: AnyActorInstance);
+    after(duration: number, fn: string, ...args: unknown[]): Promise<void>;
+    at(timestamp: number, fn: string, ...args: unknown[]): Promise<void>;
+}
+
+declare const ACTOR_CONTEXT_INTERNAL_SYMBOL: unique symbol;
+/**
+ * ActorContext class that provides access to actor methods and state
+ */
+declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    [ACTOR_CONTEXT_INTERNAL_SYMBOL]: AnyActorInstance;
+    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>);
+    /**
+     * Gets the KV storage interface.
+     */
+    get kv(): ActorKv;
+    /**
+     * Get the actor state
+     *
+     * @remarks
+     * This property is not available in `createState` since the state hasn't been created yet.
+     */
+    get state(): TState extends never ? never : TState;
+    /**
+     * Get the actor variables
+     *
+     * @remarks
+     * This property is not available in `createVars` since the variables haven't been created yet.
+     * Variables are only available if you define `vars` or `createVars` in your actor config.
+     */
+    get vars(): TVars extends never ? never : TVars;
+    /**
+     * Broadcasts an event to all connected clients.
+     * @param name - The name of the event.
+     * @param args - The arguments to send with the event.
+     */
+    broadcast<K extends keyof TEvents & string>(name: K, ...args: InferEventArgs<InferSchemaMap<TEvents>[K]>): void;
+    broadcast(name: keyof TEvents extends never ? string : never, ...args: Array<unknown>): void;
+    /**
+     * Gets the logger instance.
+     */
+    get log(): Logger;
+    /**
+     * Access to queue receive helpers.
+     */
+    get queue(): ActorQueue<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
+    /**
+     * Gets actor ID.
+     */
+    get actorId(): string;
+    /**
+     * Gets the actor name.
+     */
+    get name(): string;
+    /**
+     * Gets the actor key.
+     */
+    get key(): ActorKey;
+    /**
+     * Gets the region.
+     */
+    get region(): string;
+    /**
+     * Gets the scheduler.
+     */
+    get schedule(): Schedule;
+    /**
+     * Gets the map of connections.
+     */
+    get conns(): Map<ConnId, Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>>;
+    /**
+     * Returns the client for the given registry.
+     */
+    client<R extends Registry<any>>(): Client<R>;
+    /**
+     * Gets the database.
+     *
+     * @experimental
+     * @remarks
+     * This property is only available if you define a `db` provider in your actor config.
+     * @throws {DatabaseNotEnabled} If the database is not enabled.
+     */
+    get db(): TDatabase extends never ? never : InferDatabaseClient<TDatabase>;
+    /**
+     * Forces the state to get saved.
+     *
+     * @param opts - Options for saving the state.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /**
+     * Prevents the actor from sleeping until promise is complete.
+     */
+    waitUntil(promise: Promise<void>): void;
+    /**
+     * Prevents the actor from sleeping while the given promise is running.
+     *
+     * Use this when performing async operations in the `run` handler or other
+     * background contexts where you need to ensure the actor stays awake.
+     *
+     * Returns the resolved value and resets the sleep timer on completion.
+     * Errors are propagated to the caller.
+     */
+    keepAwake<T>(promise: Promise<T>): Promise<T>;
+    /**
+     * AbortSignal that fires when the actor is stopping.
+     */
+    get abortSignal(): AbortSignal;
+    /**
+     * True when the actor is stopping.
+     *
+     * Alias for `c.abortSignal.aborted`.
+     */
+    get aborted(): boolean;
+    /**
+     * Forces the actor to sleep.
+     *
+     * Not supported on all drivers.
+     *
+     * @experimental
+     */
+    sleep(): void;
+    /**
+     * Forces the actor to destroy.
+     *
+     * This will return immediately, then call `onStop` and `onDestroy`.
+     *
+     * @experimental
+     */
+    destroy(): void;
+}
+
+/**
+ * Base context for connection-based handlers.
+ * Extends ActorContext with connection-specific functionality.
+ */
+declare abstract class ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+    readonly conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
+}
+
+/**
+ * Context for a remote procedure call.
+ */
+declare class ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Base context for connection initialization handlers.
+ * Extends ActorContext with request-specific functionality for connection lifecycle events.
+ */
+declare abstract class ConnInitContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, TVars, TInput, TDatabase, TEvents, TQueues> {
+    /**
+     * The incoming request that initiated the connection.
+     * May be undefined for connections initiated without a direct HTTP request.
+     */
+    readonly request: Request | undefined;
+}
+
+/**
+ * Context for the onBeforeActionResponse lifecycle hook.
+ */
+declare class BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onBeforeConnect lifecycle hook.
+ */
+declare class BeforeConnectContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnInitContext<TState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onConnect lifecycle hook.
+ */
+declare class ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onCreate lifecycle hook.
+ */
+declare class CreateContext<TState, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, never, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the createConnState lifecycle hook.
+ * Called to initialize connection-specific state when a connection is created.
+ */
+declare class CreateConnStateContext<TState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnInitContext<TState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the createVars lifecycle hook.
+ */
+declare class CreateVarsContext<TState, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, never, never, never, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onDestroy lifecycle hook.
+ */
+declare class DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onDisconnect lifecycle hook.
+ */
+declare class DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for raw HTTP request handlers (onRequest).
+ */
+declare class RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+    /**
+     * The incoming HTTP request.
+     * May be undefined for request contexts initiated without a direct HTTP request.
+     */
+    readonly request: Request | undefined;
+}
+
+/**
+ * Context for the run lifecycle hook.
+ *
+ * This context is passed to the `run` handler which executes after the actor
+ * starts. It does not block actor startup and is intended for background tasks.
+ *
+ * Use `c.aborted` to detect when the actor is stopping and gracefully exit.
+ */
+declare class RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onSleep lifecycle hook.
+ */
+declare class SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onStateChange lifecycle hook.
+ */
+declare class StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for the onWake lifecycle hook.
+ */
+declare class WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+}
+
+/**
+ * Context for raw WebSocket handlers (onWebSocket).
+ */
+declare class WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> extends ConnContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> {
+    /**
+     * The incoming HTTP request that initiated the WebSocket upgrade.
+     * May be undefined for WebSocket connections initiated without a direct HTTP request.
+     */
+    readonly request: Request | undefined;
+}
+
+/** Data that's been serialized. */
+type OutputData = string | Uint8Array;
+declare const EncodingSchema: z.ZodEnum<{
+    json: "json";
+    cbor: "cbor";
+    bare: "bare";
+}>;
+/**
+ * Encoding used to communicate between the client & actor.
+ */
+type Encoding = z.infer<typeof EncodingSchema>;
+/**
+ * Helper class that helps serialize data without re-serializing for the same encoding.
+ */
+declare class CachedSerializer<TBare, TJson, T = TBare> {
+    #private;
+    constructor(data: T, versionedDataHandler: VersionedDataHandler<TBare>, version: number, zodSchema: z.ZodType<TJson>, toJson: (value: T) => TJson, toBare: (value: T) => TBare);
+    get rawData(): T;
+    serialize(encoding: Encoding): OutputData;
+}
+
+type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
+type GetUpgradeWebSocket = () => UpgradeWebSocket;
+
+declare const KEYS: {
+    PERSIST_DATA: Uint8Array<ArrayBuffer>;
+    CONN_PREFIX: Uint8Array<ArrayBuffer>;
+    INSPECTOR_TOKEN: Uint8Array<ArrayBuffer>;
+    KV: Uint8Array<ArrayBuffer>;
+    QUEUE_PREFIX: Uint8Array<ArrayBuffer>;
+    WORKFLOW_PREFIX: Uint8Array<ArrayBuffer>;
+    TRACES_PREFIX: Uint8Array<ArrayBuffer>;
+    SQLITE_PREFIX: Uint8Array<ArrayBuffer>;
+};
+
+declare const ActorKeySchema: z.ZodArray<z.ZodString>;
+type ActorKey = z.infer<typeof ActorKeySchema>;
+declare const CreateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodArray<z.ZodString>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    region: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ActorQuerySchema: z.ZodUnion<readonly [z.ZodObject<{
+    getForId: z.ZodObject<{
+        name: z.ZodString;
+        actorId: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    getForKey: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    getOrCreateForKey: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    create: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString>;
+        input: z.ZodOptional<z.ZodUnknown>;
+        region: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>;
+type ActorQuery = z.infer<typeof ActorQuerySchema>;
+/**
+ * Interface representing a request to create a actor.
+ */
+type CreateRequest = z.infer<typeof CreateRequestSchema>;
+
+interface ActorInspectorEmitterEvents {
+    stateUpdated: (state: unknown) => void;
+    connectionsUpdated: () => void;
+    queueUpdated: () => void;
+    workflowHistoryUpdated: (history: WorkflowHistory) => void;
+}
+/**
+ * Provides a unified interface for inspecting actor external and internal state.
+ */
+declare class ActorInspector {
+    #private;
+    private readonly actor;
+    readonly emitter: nanoevents.Emitter<ActorInspectorEmitterEvents>;
+    constructor(actor: AnyActorInstance);
+    getQueueSize(): number;
+    getQueueStatus(limit: number): Promise<QueueStatus>;
+    updateQueueSize(size: number): void;
+    isWorkflowEnabled(): boolean;
+    getWorkflowHistory(): WorkflowHistory | null;
+    isDatabaseEnabled(): boolean;
+    getDatabaseSchema(): Promise<ArrayBuffer>;
+    getDatabaseTableRows(table: string, limit: number, offset: number): Promise<ArrayBuffer>;
+    isStateEnabled(): boolean;
+    getState(): ArrayBuffer;
+    getRpcs(): string[];
+    getConnections(): {
+        type: string | undefined;
+        id: string;
+        details: ArrayBuffer;
+    }[];
+    setState(state: ArrayBuffer): Promise<void>;
+    executeAction(name: string, params: ArrayBuffer): Promise<ArrayBuffer>;
+    getStateJson(): unknown;
+    setStateJson(state: unknown): Promise<void>;
+    getConnectionsJson(): {
+        id: string;
+        details: unknown;
+    }[];
+    executeActionJson(name: string, args: unknown[]): Promise<unknown>;
+    getTracesJson(options: {
+        startMs: number;
+        endMs: number;
+        limit: number;
+    }): Promise<{
+        otlp: unknown;
+        clamped: boolean;
+    }>;
+    getWorkflowHistoryJson(): {
+        history: unknown | null;
+        isWorkflowEnabled: boolean;
+    };
+    getQueueStatusJson(limit: number): Promise<{
+        size: number;
+        maxSize: number;
+        truncated: boolean;
+        messages: {
+            id: number;
+            name: string;
+            createdAtMs: number;
+        }[];
+    }>;
+}
+
+declare enum DriverReadyState {
+    UNKNOWN = -1,
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+interface ConnDriver {
+    /** The type of driver. Used for debug purposes only. */
+    type: string;
+    /**
+     * If defined, this connection driver talks the RivetKit client driver (see
+     * schemas/client-protocol/).
+     *
+     * If enabled, events like `Init`, subscription events, etc. will be sent
+     * to this connection.
+     */
+    rivetKitProtocol?: {
+        /** Sends a RivetKit client message. */
+        sendMessage(actor: AnyActorInstance, conn: AnyConn, message: CachedSerializer<any, any, any>): void;
+    };
+    /**
+     * If the connection can be hibernated. If true, this will allow the actor to go to sleep while the connection is still active.
+     **/
+    hibernatable?: {
+        gatewayId: ArrayBuffer;
+        requestId: ArrayBuffer;
+    };
+    /**
+     * This returns a promise since we commonly disconnect at the end of a program, and not waiting will cause the socket to not close cleanly.
+     */
+    disconnect(actor: AnyActorInstance, conn: AnyConn, reason?: string): Promise<void>;
+    /** Terminates the connection without graceful handling. */
+    terminate?(actor: AnyActorInstance, conn: AnyConn): void;
+    /**
+     * Returns the ready state of the connection.
+     * This is used to determine if the connection is ready to send messages, or if the connection is stale.
+     */
+    getConnectionReadyState(actor: AnyActorInstance, conn: AnyConn): DriverReadyState | undefined;
+}
+
+/**
+ * Persisted data structures for connections.
+ *
+ * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
+ */
+
+type GatewayId = ArrayBuffer;
+type RequestId = ArrayBuffer;
+/** Event subscription for connection */
+interface PersistedSubscription {
+    eventName: string;
+}
+/** Connection associated with hibernatable WebSocket that should persist across lifecycles */
+interface PersistedConn<CP, CS> {
+    /** Connection ID generated by RivetKit */
+    id: string;
+    parameters: CP;
+    state: CS;
+    subscriptions: PersistedSubscription[];
+    gatewayId: GatewayId;
+    requestId: RequestId;
+    serverMessageIndex: number;
+    clientMessageIndex: number;
+    requestPath: string;
+    requestHeaders: Record<string, string>;
+}
+
+/**
+ * Manages all connection-related operations for an actor instance.
+ * Handles connection creation, tracking, hibernation, and cleanup.
+ */
+declare class ConnectionManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>);
+    get connections(): Map<ConnId, Conn<S, CP, CS, V, I, DB, E, Q>>;
+    getConnForId(id: string): Conn<S, CP, CS, V, I, DB, E, Q> | undefined;
+    get connsWithPersistChanged(): Set<ConnId>;
+    get pendingDisconnectCount(): number;
+    clearConnWithPersistChanged(): void;
+    markConnWithPersistChanged(conn: Conn<S, CP, CS, V, I, DB, E, Q>): void;
+    /**
+     * Handles pre-connection logic (i.e. auth & create state) before actually connecting the connection.
+     */
+    prepareConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined, isHibernatable: boolean, isRestoringHibernatable: boolean): Promise<Conn<S, CP, CS, V, I, DB, E, Q>>;
+    /**
+     * Adds a connection form prepareConn to the actor and calls onConnect.
+     *
+     * This method is intentionally not async since it needs to be called in
+     * `onOpen` for WebSockets. If this is async, the order of open events will
+     * be messed up and cause race conditions that can drop WebSocket messages.
+     * So all async work in prepareConn.
+     */
+    connectConn(conn: Conn<S, CP, CS, V, I, DB, E, Q>): void;
+    /**
+     * Handle connection disconnection.
+     *
+     * This is called by `Conn.disconnect`. This should not call `Conn.disconnect.`
+     */
+    connDisconnected(conn: Conn<S, CP, CS, V, I, DB, E, Q>): Promise<void>;
+    cleanupPersistedHibernatableConnections(reason?: string): Promise<number>;
+    /**
+     * Utilify function for call sites that don't need a separate prepare and connect phase.
+     */
+    prepareAndConnectConn(driver: ConnDriver, params: CP, request: Request | undefined, requestPath: string | undefined, requestHeaders: Record<string, string> | undefined): Promise<Conn<S, CP, CS, V, I, DB, E, Q>>;
+    /**
+     * Restores connections from persisted data during actor initialization.
+     */
+    restoreConnections(connections: PersistedConn<CP, CS>[]): void;
+    findHibernatableConn(gatewayIdBuf: ArrayBuffer, requestIdBuf: ArrayBuffer): Conn<S, CP, CS, V, I, DB, E, Q> | undefined;
+}
+
+/**
+ * Manages event subscriptions and broadcasting for actor instances.
+ * Handles subscription tracking and efficient message distribution to connected clients.
+ */
+declare class EventManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>);
+    /**
+     * Adds a subscription for a connection to an event.
+     *
+     * @param eventName - The name of the event to subscribe to
+     * @param connection - The connection subscribing to the event
+     * @param fromPersist - Whether this subscription is being restored from persistence
+     */
+    addSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromPersist: boolean): void;
+    /**
+     * Removes a subscription for a connection from an event.
+     *
+     * @param eventName - The name of the event to unsubscribe from
+     * @param connection - The connection unsubscribing from the event
+     * @param fromRemoveConn - Whether this is being called as part of connection removal
+     */
+    removeSubscription(eventName: string, connection: Conn<S, CP, CS, V, I, DB, E, Q>, fromRemoveConn: boolean): void;
+    /**
+     * Broadcasts an event to all subscribed connections.
+     *
+     * @param name - The name of the event to broadcast
+     * @param args - The arguments to send with the event
+     */
+    broadcast<Args extends Array<unknown>>(name: string, ...args: Args): void;
+    /**
+     * Gets all subscribers for a specific event.
+     *
+     * @param eventName - The name of the event
+     * @returns Set of connections subscribed to the event, or undefined if no subscribers
+     */
+    getSubscribers(eventName: string): Set<Conn<S, CP, CS, V, I, DB, E, Q>> | undefined;
+    /**
+     * Gets all events and their subscriber counts.
+     *
+     * @returns Map of event names to subscriber counts
+     */
+    getEventStats(): Map<string, number>;
+    /**
+     * Clears all subscriptions for a connection.
+     * Used during connection cleanup.
+     *
+     * @param connection - The connection to clear subscriptions for
+     */
+    clearConnectionSubscriptions(connection: Conn<S, CP, CS, V, I, DB, E, Q>): void;
+    /**
+     * Gets the total number of unique events being subscribed to.
+     */
+    get eventCount(): number;
+    /**
+     * Gets the total number of subscriptions across all events.
+     */
+    get totalSubscriptionCount(): number;
+    /**
+     * Checks if an event has any subscribers.
+     *
+     * @param eventName - The name of the event to check
+     * @returns True if the event has at least one subscriber
+     */
+    hasSubscribers(eventName: string): boolean;
+}
+
+/**
+ * Persisted data structures for actors.
+ *
+ * Keep this file in sync with the Connection section of rivetkit-typescript/packages/rivetkit/schemas/actor-persist/
+ */
+
+type Cbor = ArrayBuffer;
+/** Scheduled event to be executed at a specific timestamp */
+interface PersistedScheduleEvent {
+    eventId: string;
+    timestamp: number;
+    action: string;
+    args?: Cbor;
+}
+/** State object that gets automatically persisted to storage */
+interface PersistedActor<S, I> {
+    /** Input data passed to the actor on initialization */
+    input?: I;
+    hasInitialized: boolean;
+    state: S;
+    scheduledEvents: PersistedScheduleEvent[];
+}
+
+interface SaveStateOptions {
+    /**
+     * Forces the state to be saved immediately. This function will return when the state has saved successfully.
+     */
+    immediate?: boolean;
+    /** Bypass ready check for stopping. */
+    allowStoppingState?: boolean;
+    /**
+     * Maximum time in milliseconds to wait before forcing a save.
+     *
+     * If a save is already scheduled to occur later than this deadline, it will be rescheduled earlier.
+     */
+    maxWait?: number;
+}
+/**
+ * Manages actor state persistence, proxying, and synchronization.
+ * Handles automatic state change detection and throttled persistence to KV storage.
+ */
+declare class StateManager$1<S, CP, CS, I, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    constructor(actor: ActorInstance<S, CP, CS, any, I, any, E, Q>, actorDriver: ActorDriver, config: any);
+    get persist(): PersistedActor<S, I>;
+    get persistRaw(): PersistedActor<S, I>;
+    get persistChanged(): boolean;
+    get state(): S;
+    set state(value: S);
+    get stateEnabled(): boolean;
+    /**
+     * Initializes state from persisted data or creates new state.
+     */
+    initializeState(persistData: PersistedActor<S, I>): Promise<void>;
+    /**
+     * Creates proxy for persist object that handles automatic state change detection.
+     */
+    initPersistProxy(target: PersistedActor<S, I>): undefined;
+    /**
+     * Forces the state to get saved.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /**
+     * Throttled save state method. Used to write to KV at a reasonable cadence.
+     *
+     * Passing a maxWait will override the stateSaveInterval with the min
+     * between that and the maxWait.
+     */
+    savePersistThrottled(maxWait?: number): void;
+    /**
+     * Clears any pending save timeout.
+     */
+    clearPendingSaveTimeout(): void;
+    /**
+     * Waits for any pending write operations to complete.
+     */
+    waitForPendingWrites(): Promise<void>;
+}
+
+/** Actor type alias with all `any` types. Used for `extends` in classes referencing this actor. */
+type AnyActorInstance = ActorInstance<any, any, any, any, any, any, any, any>;
+declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    actorContext: ActorContext<S, CP, CS, V, I, DB, E, Q>;
+    driver: ActorDriver;
+    connectionManager: ConnectionManager<S, CP, CS, V, I, DB, E, Q>;
+    stateManager: StateManager$1<S, CP, CS, I, E, Q>;
+    eventManager: EventManager<S, CP, CS, V, I, DB, E, Q>;
+    queueManager: QueueManager<S, CP, CS, V, I, DB, E, Q>;
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB, E, Q>);
+    get log(): Logger;
+    get rLog(): Logger;
+    get isStopping(): boolean;
+    get id(): string;
+    get name(): string;
+    get key(): ActorKey;
+    get region(): string;
+    get inlineClient(): Client<Registry<any>>;
+    get inspector(): ActorInspector;
+    get traces(): Traces<OtlpExportTraceServiceRequestJson>;
+    get inspectorToken(): string | undefined;
+    getCurrentTraceSpan(): SpanHandle | null;
+    startTraceSpan(name: string, attributes?: Record<string, unknown>): SpanHandle;
+    endTraceSpan(handle: SpanHandle, status?: SpanStatusInput): void;
+    runInTraceSpan<T>(name: string, attributes: Record<string, unknown> | undefined, fn: () => T | Promise<T>): Promise<T>;
+    emitTraceEvent(name: string, attributes?: Record<string, unknown>, handle?: SpanHandle): void;
+    get conns(): Map<ConnId, Conn<S, CP, CS, V, I, DB, E, Q>>;
+    get schedule(): Schedule;
+    get abortSignal(): AbortSignal;
+    get actions(): string[];
+    get config(): ActorConfig<S, CP, CS, V, I, DB, E, Q>;
+    get persist(): PersistedActor<S, I>;
+    get state(): S;
+    set state(value: S);
+    get stateEnabled(): boolean;
+    get connStateEnabled(): boolean;
+    get vars(): V;
+    get db(): InferDatabaseClient<DB>;
+    start(actorDriver: ActorDriver, inlineClient: Client<Registry<any>>, actorId: string, name: string, key: ActorKey, region: string): Promise<void>;
+    isReady(): boolean;
+    assertReady(allowStoppingState?: boolean): void;
+    cleanupPersistedConnections(reason?: string): Promise<number>;
+    onStop(mode: "sleep" | "destroy"): Promise<void>;
+    startSleep(): void;
+    startDestroy(): void;
+    beginHonoHttpRequest(): void;
+    endHonoHttpRequest(): void;
+    processMessage(message: {
+        body: {
+            tag: "ActionRequest";
+            val: {
+                id: bigint;
+                name: string;
+                args: unknown;
+            };
+        } | {
+            tag: "SubscriptionRequest";
+            val: {
+                eventName: string;
+                subscribe: boolean;
+            };
+        };
+    }, conn: Conn<S, CP, CS, V, I, DB, E, Q>): Promise<void>;
+    assertCanSubscribe(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, eventName: string): Promise<void>;
+    assertCanPublish(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, queueName: string): Promise<void>;
+    executeAction(ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>, actionName: string, args: unknown[]): Promise<unknown>;
+    handleRawRequest(conn: Conn<S, CP, CS, V, I, DB, E, Q>, request: Request): Promise<Response>;
+    handleRawWebSocket(conn: Conn<S, CP, CS, V, I, DB, E, Q>, websocket: UniversalWebSocket, request?: Request): void;
+    scheduleEvent(timestamp: number, action: string, args: unknown[]): Promise<void>;
+    onAlarm(): Promise<void>;
+    waitUntil(promise: Promise<void>): void;
+    /**
+     * Prevents the actor from sleeping while the given promise is running.
+     *
+     * Use this when performing async operations in the `run` handler or other
+     * background contexts where you need to ensure the actor stays awake.
+     *
+     * Returns the resolved value and resets the sleep timer on completion.
+     * Errors are propagated to the caller.
+     */
+    keepAwake<T>(promise: Promise<T>): Promise<T>;
+    beginQueueWait(): void;
+    endQueueWait(): void;
+    resetSleepTimer(): void;
+}
+
+/** Pick a subset of persisted data used to represent ephemeral connections */
+type EphemeralConn<CP, CS> = Pick<PersistedConn<CP, CS>, "id" | "parameters" | "state">;
+type ConnDataInput<CP, CS> = {
+    ephemeral: EphemeralConn<CP, CS>;
+} | {
+    hibernatable: PersistedConn<CP, CS>;
+};
+/**
+ * Manages connection state persistence, proxying, and change tracking.
+ * Handles automatic state change detection for connection-specific state.
+ */
+declare class StateManager<CP, CS> {
+    #private;
+    constructor(conn: Conn<any, CP, CS, any, any, any, any, any>, data: ConnDataInput<CP, CS>);
+    /**
+     * Returns the ephemeral or persisted data for this connectioned.
+     *
+     * This property is used to be able to treat both memory & persist conns
+     * identical by looking up the correct underlying data structure.
+     */
+    get ephemeralData(): EphemeralConn<CP, CS>;
+    get hibernatableData(): PersistedConn<CP, CS> | undefined;
+    hibernatableDataOrError(): PersistedConn<CP, CS>;
+    get hibernatableDataRaw(): PersistedConn<CP, CS> | undefined;
+    get stateEnabled(): boolean;
+    get state(): CS;
+    set state(value: CS);
+    addSubscription({ eventName }: {
+        eventName: string;
+    }): void;
+    removeSubscription({ eventName }: {
+        eventName: string;
+    }): boolean | undefined;
+}
+
+type ConnId = string;
+type AnyConn = Conn<any, any, any, any, any, any, any, any>;
+declare const CONN_CONNECTED_SYMBOL: unique symbol;
+declare const CONN_SPEAKS_RIVETKIT_SYMBOL: unique symbol;
+declare const CONN_DRIVER_SYMBOL: unique symbol;
+declare const CONN_ACTOR_SYMBOL: unique symbol;
+declare const CONN_STATE_MANAGER_SYMBOL: unique symbol;
+declare const CONN_SEND_MESSAGE_SYMBOL: unique symbol;
+/**
+ * Represents a client connection to a actor.
+ *
+ * Manages connection-specific data and controls the connection lifecycle.
+ *
+ * @see {@link https://rivet.dev/docs/connections|Connection Documentation}
+ */
+declare class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>> {
+    #private;
+    get [CONN_ACTOR_SYMBOL](): ActorInstance<S, CP, CS, V, I, DB, E, Q>;
+    get [CONN_STATE_MANAGER_SYMBOL](): StateManager<CP, CS>;
+    /**
+     * Connections exist before being connected to an actor. If true, this
+     * connection has been connected.
+     **/
+    [CONN_CONNECTED_SYMBOL]: boolean;
+    /**
+     * If undefined, then no socket is connected to this conn
+     */
+    [CONN_DRIVER_SYMBOL]?: ConnDriver;
+    /**
+     * If this connection is speaking the RivetKit protocol. If false, this is
+     * a raw connection for WebSocket or fetch or inspector.
+     **/
+    get [CONN_SPEAKS_RIVETKIT_SYMBOL](): boolean;
+    subscriptions: Set<string>;
+    get params(): CP;
+    /**
+     * Gets the current state of the connection.
+     *
+     * Throws an error if the state is not enabled.
+     */
+    get state(): CS;
+    /**
+     * Sets the state of the connection.
+     *
+     * Throws an error if the state is not enabled.
+     */
+    set state(value: CS);
+    /**
+     * Unique identifier for the connection.
+     */
+    get id(): ConnId;
+    /**
+     * @experimental
+     *
+     * If the underlying connection can hibernate.
+     */
+    get isHibernatable(): boolean;
+    /**
+     * Initializes a new instance of the Connection class.
+     *
+     * This should only be constructed by {@link Actor}.
+     *
+     * @protected
+     */
+    constructor(actor: ActorInstance<S, CP, CS, V, I, DB, E, Q>, data: ConnDataInput<CP, CS>);
+    /**
+     * Sends a raw message to the underlying connection.
+     */
+    [CONN_SEND_MESSAGE_SYMBOL](message: CachedSerializer<any, any, any>): void;
+    /**
+     * Sends an event with arguments to the client.
+     *
+     * @param eventName - The name of the event.
+     * @param args - The arguments for the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     */
+    send<K extends keyof E & string>(eventName: K, ...args: InferEventArgs<InferSchemaMap<E>[K]>): void;
+    send(eventName: keyof E extends never ? string : never, ...args: unknown[]): void;
+    /**
+     * Disconnects the client with an optional reason.
+     *
+     * @param reason - The reason for disconnection.
+     */
+    disconnect(reason?: string): Promise<void>;
+}
+
+type InspectorUnsubscribe = () => void;
+declare const RunConfigSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    icon: z.ZodOptional<z.ZodString>;
+    run: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+    inspector: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        workflow: z.ZodOptional<z.ZodObject<{
+            getHistory: z.ZodCustom<() => unknown, () => unknown>;
+            onHistoryUpdated: z.ZodOptional<z.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+type RunConfigRuntime = z.infer<typeof RunConfigSchema>;
+type RunConfig<TState = unknown, TConnParams = unknown, TConnState = unknown, TVars = unknown, TInput = unknown, TDatabase extends AnyDatabaseProvider = AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> = Omit<RunConfigRuntime, "run"> & {
+    run: (c: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+};
+declare const ActorConfigSchema: z.ZodObject<{
+    onCreate: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onDestroy: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onWake: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onSleep: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    run: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        run: z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>;
+        inspector: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+            workflow: z.ZodOptional<z.ZodObject<{
+                getHistory: z.ZodCustom<() => unknown, () => unknown>;
+                onHistoryUpdated: z.ZodOptional<z.ZodCustom<(listener: (history: unknown) => void) => InspectorUnsubscribe, (listener: (history: unknown) => void) => InspectorUnsubscribe>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>]>>;
+    onStateChange: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onBeforeConnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onConnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onDisconnect: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onBeforeActionResponse: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onRequest: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    onWebSocket: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    actions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>>;
+    events: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    queues: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    state: z.ZodOptional<z.ZodAny>;
+    createState: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    connState: z.ZodOptional<z.ZodAny>;
+    createConnState: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    vars: z.ZodOptional<z.ZodAny>;
+    db: z.ZodOptional<z.ZodAny>;
+    createVars: z.ZodOptional<z.ZodCustom<(...args: unknown[]) => unknown, (...args: unknown[]) => unknown>>;
+    options: z.ZodPrefault<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        createVarsTimeout: z.ZodDefault<z.ZodNumber>;
+        createConnStateTimeout: z.ZodDefault<z.ZodNumber>;
+        onConnectTimeout: z.ZodDefault<z.ZodNumber>;
+        onSleepTimeout: z.ZodDefault<z.ZodNumber>;
+        onDestroyTimeout: z.ZodDefault<z.ZodNumber>;
+        stateSaveInterval: z.ZodDefault<z.ZodNumber>;
+        actionTimeout: z.ZodDefault<z.ZodNumber>;
+        waitUntilTimeout: z.ZodDefault<z.ZodNumber>;
+        runStopTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessInterval: z.ZodDefault<z.ZodNumber>;
+        noSleep: z.ZodDefault<z.ZodBoolean>;
+        sleepTimeout: z.ZodDefault<z.ZodNumber>;
+        maxQueueSize: z.ZodDefault<z.ZodNumber>;
+        maxQueueMessageSize: z.ZodDefault<z.ZodNumber>;
+        canHibernateWebSocket: z.ZodDefault<z.ZodUnion<readonly [z.ZodBoolean, z.ZodCustom<(request: Request) => boolean, (request: Request) => boolean>]>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
+    state: TState;
+} | {
+    createState: (c: CreateContext<TState, TInput, TDatabase, TEvents, TQueues>, input: TInput) => TState | Promise<TState>;
+} | Record<never, never>;
+type CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
+    connState: TConnState;
+} | {
+    createConnState: (c: CreateConnStateContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => TConnState | Promise<TConnState>;
+} | Record<never, never>;
+/**
+ * @experimental
+ */
+type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig> = {
+    /**
+     * @experimental
+     */
+    vars: TVars;
+} | {
+    /**
+     * @experimental
+     */
+    createVars: (c: CreateVarsContext<TState, TInput, TDatabase, TEvents, TQueues>, driverCtx: any) => TVars | Promise<TVars>;
+} | Record<never, never>;
+interface Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> {
+    [Action: string]: (c: ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, ...args: any[]) => any;
+}
+interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig, TQueues extends QueueSchemaConfig, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>> {
+    /**
+     * Called when the actor is first initialized.
+     *
+     * Use this hook to initialize your actor's state.
+     * This is called before any other lifecycle hooks.
+     */
+    onCreate?: (c: CreateContext<TState, TInput, TDatabase, TEvents, TQueues>, input: TInput) => void | Promise<void>;
+    /**
+     * Called when the actor is destroyed.
+     */
+    onDestroy?: (c: DestroyContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called when the actor is started and ready to receive connections and action.
+     *
+     * Use this hook to initialize resources needed for the actor's operation
+     * (timers, external connections, etc.)
+     *
+     * @returns Void or a Promise that resolves when startup is complete
+     */
+    onWake?: (c: WakeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called when the actor is stopping or sleeping.
+     *
+     * Use this hook to clean up resources, save state, or perform
+     * any shutdown operations before the actor sleeps or stops.
+     *
+     * Not supported on all platforms.
+     *
+     * @returns Void or a Promise that resolves when shutdown is complete
+     */
+    onSleep?: (c: SleepContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called after the actor starts up. Does not block actor startup.
+     *
+     * Use this for background tasks like:
+     * - Reading from queues in a loop
+     * - Tick loops for periodic work
+     * - Custom workflow logic
+     *
+     * **Important:** The actor may go to sleep at any time during the `run`
+     * handler. Use `c.keepAwake(promise)` to wrap async operations that should
+     * not be interrupted by sleep.
+     *
+     * The handler receives an abort signal via `c.abortSignal` and a
+     * `c.aborted` alias for loop checks. Use these to gracefully exit.
+     *
+     * If this handler exits or throws, the actor will crash and reschedule.
+     * On shutdown, the actor waits for this handler to complete with a
+     * configurable timeout (options.runStopTimeout, default 15s).
+     *
+     * Can be either a function or a RunConfig object with optional name/icon metadata.
+     *
+     * @returns Void or a Promise. If the promise exits, the actor crashes.
+     */
+    run?: ((c: RunContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>) | RunConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>;
+    /**
+     * Called when the actor's state changes.
+     *
+     * Use this hook to react to state changes, such as updating
+     * external systems or triggering events.
+     *
+     * State changes made within this hook will NOT trigger
+     * another onStateChange call, preventing infinite recursion.
+     *
+     * @param newState The updated state
+     */
+    onStateChange?: (c: StateChangeContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, newState: TState) => void;
+    /**
+     * Called before a client connects to the actor.
+     *
+     * Use this hook to determine if a connection should be accepted
+     * and to initialize connection-specific state.
+     *
+     * @param opts Connection parameters including client-provided data
+     * @returns The initial connection state or a Promise that resolves to it
+     * @throws Throw an error to reject the connection
+     */
+    onBeforeConnect?: (c: BeforeConnectContext<TState, TVars, TInput, TDatabase, TEvents, TQueues>, params: TConnParams) => void | Promise<void>;
+    /**
+     * Called when a client successfully connects to the actor.
+     *
+     * Use this hook to perform actions when a connection is established,
+     * such as sending initial data or updating the actor's state.
+     *
+     * @param conn The connection object
+     * @returns Void or a Promise that resolves when connection handling is complete
+     */
+    onConnect?: (c: ConnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called when a client disconnects from the actor.
+     *
+     * Use this hook to clean up resources associated with the connection
+     * or update the actor's state.
+     *
+     * @param conn The connection that is being closed
+     * @returns Void or a Promise that resolves when disconnect handling is complete
+     */
+    onDisconnect?: (c: DisconnectContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>) => void | Promise<void>;
+    /**
+     * Called before sending an action response to the client.
+     *
+     * Use this hook to modify or transform the output of an action before it's sent
+     * to the client. This is useful for formatting responses, adding metadata,
+     * or applying transformations to the output.
+     *
+     * @param name The name of the action that was called
+     * @param args The arguments that were passed to the action
+     * @param output The output that will be sent to the client
+     * @returns The modified output to send to the client
+     */
+    onBeforeActionResponse?: <Out>(c: BeforeActionResponseContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, name: string, args: unknown[], output: Out) => Out | Promise<Out>;
+    /**
+     * Called when a raw HTTP request is made to the actor.
+     *
+     * This handler receives raw HTTP requests made to `/actors/{actorName}/http/*` endpoints.
+     * Use this hook to handle custom HTTP patterns, REST APIs, or other HTTP-based protocols.
+     *
+     * @param c The request context with access to the connection
+     * @param request The raw HTTP request object
+     * @param opts Additional options
+     * @returns A Response object to send back, or void to continue with default routing
+     */
+    onRequest?: (c: RequestContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, request: Request) => Response | Promise<Response>;
+    /**
+     * Called when a raw WebSocket connection is established to the actor.
+     *
+     * This handler receives WebSocket connections made to `/actors/{actorName}/websocket/*` endpoints.
+     * Use this hook to handle custom WebSocket protocols, binary streams, or other WebSocket-based communication.
+     *
+     * @param c The WebSocket context with access to the connection
+     * @param websocket The raw WebSocket connection
+     * @param opts Additional options including the original HTTP upgrade request
+     */
+    onWebSocket?: (c: WebSocketContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>, websocket: UniversalWebSocket) => void | Promise<void>;
+    actions?: TActions;
+    /**
+     * Schema map for events broadcasted by this actor.
+     */
+    events?: TEvents;
+    /**
+     * Schema map for queue payloads sent by this actor.
+     */
+    queues?: TQueues;
+}
+type ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> = {
+    /**
+     * @experimental
+     */
+    db: TDatabase;
+} | Record<never, never>;
+type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TEvents extends EventSchemaConfig = Record<never, never>, TQueues extends QueueSchemaConfig = Record<never, never>> = Omit<z.infer<typeof ActorConfigSchema>, "actions" | "events" | "queues" | "onCreate" | "onDestroy" | "onWake" | "onSleep" | "run" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onRequest" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues, Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues>> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TEvents, TQueues> & ActorDatabaseConfig<TDatabase>;
+
+type ManagerDriverBuilder = (config: RegistryConfig) => ManagerDriver;
+interface ManagerDriver {
+    getForId(input: GetForIdInput): Promise<ActorOutput | undefined>;
+    getWithKey(input: GetWithKeyInput): Promise<ActorOutput | undefined>;
+    getOrCreateWithKey(input: GetOrCreateWithKeyInput): Promise<ActorOutput>;
+    createActor(input: CreateInput): Promise<ActorOutput>;
+    listActors(input: ListActorsInput): Promise<ActorOutput[]>;
+    sendRequest(actorId: string, actorRequest: Request): Promise<Response>;
+    openWebSocket(path: string, actorId: string, encoding: Encoding, params: unknown): Promise<UniversalWebSocket>;
+    proxyRequest(c: Context, actorRequest: Request, actorId: string): Promise<Response>;
+    proxyWebSocket(c: Context, path: string, actorId: string, encoding: Encoding, params: unknown): Promise<Response>;
+    /**
+     * Build a public gateway URL for a specific actor.
+     *
+     * This lives on the driver because the base endpoint varies by runtime.
+     */
+    buildGatewayUrl(actorId: string): Promise<string>;
+    displayInformation(): ManagerDisplayInformation;
+    extraStartupLog?: () => Record<string, unknown>;
+    modifyManagerRouter?: (config: RegistryConfig, router: Hono) => void;
+    /**
+     * Allows lazily setting getUpgradeWebSocket after the manager router has
+     * been initialized.
+     **/
+    setGetUpgradeWebSocket(getUpgradeWebSocket: GetUpgradeWebSocket): void;
+    /** Read a key. Returns null if the key doesn't exist. */
+    kvGet(actorId: string, key: Uint8Array): Promise<string | null>;
+}
+interface ManagerDisplayInformation {
+    properties: Record<string, string>;
+}
+interface GetForIdInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    actorId: string;
+}
+interface GetWithKeyInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+}
+interface GetOrCreateWithKeyInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+    input?: unknown;
+    region?: string;
+}
+interface CreateInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key: ActorKey;
+    input?: unknown;
+    region?: string;
+}
+interface ListActorsInput<E extends Env = any> {
+    c?: Context | undefined;
+    name: string;
+    key?: string;
+    includeDestroyed?: boolean;
+}
+interface ActorOutput {
+    actorId: string;
+    name: string;
+    key: ActorKey;
+    createTs?: number;
+    startTs?: number | null;
+    connectableTs?: number | null;
+    sleepTs?: number | null;
+    destroyTs?: number | null;
+    error?: unknown;
+}
+
+type ActorDriverBuilder = (config: RegistryConfig, managerDriver: ManagerDriver, inlineClient: AnyClient) => ActorDriver;
+interface ActorDriver {
+    loadActor(actorId: string): Promise<AnyActorInstance>;
+    getContext(actorId: string): unknown;
+    /** Batch write multiple key-value pairs. Keys and values are Uint8Arrays. */
+    kvBatchPut(actorId: string, entries: [Uint8Array, Uint8Array][]): Promise<void>;
+    /** Batch read multiple keys. Returns null for keys that don't exist. */
+    kvBatchGet(actorId: string, keys: Uint8Array[]): Promise<(Uint8Array | null)[]>;
+    /** Batch delete multiple keys. */
+    kvBatchDelete(actorId: string, keys: Uint8Array[]): Promise<void>;
+    /** List all keys with a given prefix. */
+    kvListPrefix(actorId: string, prefix: Uint8Array): Promise<[Uint8Array, Uint8Array][]>;
+    /** ActorInstance ensure that only one instance of setAlarm is called in parallel at a time. */
+    setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void>;
+    /**
+     * Override the default raw database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed SQLite client.
+     * @experimental
+     */
+    overrideRawDatabaseClient?(actorId: string): Promise<RawDatabaseClient | undefined>;
+    /**
+     * Override the default Drizzle database client for the actor.
+     * If not provided, rivetkit will construct a KV-backed Drizzle client.
+     * @experimental
+     */
+    overrideDrizzleDatabaseClient?(actorId: string): Promise<BaseSQLiteDatabase<any, any, any, any> | undefined>;
+    /**
+     * Creates a SQLite VFS instance for creating KV-backed databases.
+     * If not provided, the database provider will need an override.
+     *
+     * @rivetkit/sqlite's async build is not re-entrant per module instance. Drivers
+     * should return a new instance per call for actor-level isolation.
+     *
+     * This is a method (not a property) so drivers can use dynamic imports,
+     * keeping the core driver tree-shakeable from @rivetkit/sqlite.
+     */
+    createSqliteVfs?(): SqliteVfs | Promise<SqliteVfs>;
+    /**
+     * Requests the actor to go to sleep.
+     *
+     * This will call `ActorInstance.onStop` independently.
+     */
+    startSleep?(actorId: string): void;
+    /**
+     * Destroys the actor and its associated data.
+     *
+     * This will call `ActorInstance.onStop` independently.
+     */
+    startDestroy(actorId: string): void;
+    /**
+     * Shuts down the actor runner.
+     */
+    shutdownRunner?(immediate: boolean): Promise<void>;
+    /** This handles the serverless start request. This should manage the lifecycle of the runner tied to the request lifecycle. */
+    serverlessHandleStart?(c: Context): Promise<Response>;
+    /** Extra properties to add to logs for each actor. */
+    getExtraActorLogParams?(): Record<string, string>;
+    onBeforeActorStart?(actor: AnyActorInstance): Promise<void>;
+    onCreateConn?(conn: AnyConn): void;
+    onDestroyConn?(conn: AnyConn): void;
+    onBeforePersistConn?(conn: AnyConn): void;
+    onAfterPersistConn?(conn: AnyConn): void;
+}
+
+declare const ActorsSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodCustom<ActorDefinition<any, any, any, any, any, any, any, any, any>, ActorDefinition<any, any, any, any, any, any, any, any, any>>>;
+type RegistryActors = z$1.infer<typeof ActorsSchema>;
+declare const RegistryConfigSchema: z$1.ZodPipe<z$1.ZodObject<{
+    use: z$1.ZodRecord<z$1.ZodString, z$1.ZodCustom<AnyActorDefinition, AnyActorDefinition>>;
+    test: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        enabled: z$1.ZodBoolean;
+    }, z$1.core.$strip>>>;
+    driver: z$1.ZodOptional<z$1.ZodObject<{
+        name: z$1.ZodString;
+        displayName: z$1.ZodString;
+        manager: z$1.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
+        actor: z$1.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
+        autoStartActorDriver: z$1.ZodBoolean;
+    }, z$1.core.$strip>>;
+    storagePath: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    maxIncomingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    maxOutgoingMessageSize: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    noWelcome: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodBoolean>>;
+    logging: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        baseLogger: z$1.ZodOptional<z$1.ZodCustom<Logger, Logger>>;
+        level: z$1.ZodOptional<z$1.ZodEnum<{
+            error: "error";
+            trace: "trace";
+            fatal: "fatal";
+            warn: "warn";
+            info: "info";
+            debug: "debug";
+            silent: "silent";
+        }>>;
+    }, z$1.core.$strip>>>;
+    endpoint: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    token: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    namespace: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    headers: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>>;
+    serveManager: z$1.ZodOptional<z$1.ZodBoolean>;
+    managerBasePath: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+    managerPort: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodNumber>>;
+    managerHost: z$1.ZodOptional<z$1.ZodString>;
+    inspector: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        enabled: z$1.ZodDefault<z$1.ZodBoolean>;
+        token: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodCustom<() => string, () => string>>>;
+        defaultEndpoint: z$1.ZodOptional<z$1.ZodString>;
+    }, z$1.core.$strip>>>;
+    serverless: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        spawnEngine: z$1.ZodDefault<z$1.ZodBoolean>;
+        engineVersion: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+        configureRunnerPool: z$1.ZodOptional<z$1.ZodOptional<z$1.ZodObject<{
+            name: z$1.ZodOptional<z$1.ZodString>;
+            url: z$1.ZodString;
+            headers: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+            maxRunners: z$1.ZodOptional<z$1.ZodNumber>;
+            minRunners: z$1.ZodOptional<z$1.ZodNumber>;
+            requestLifespan: z$1.ZodOptional<z$1.ZodNumber>;
+            runnersMargin: z$1.ZodOptional<z$1.ZodNumber>;
+            slotsPerRunner: z$1.ZodOptional<z$1.ZodNumber>;
+            metadata: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodUnknown>>;
+            metadataPollInterval: z$1.ZodOptional<z$1.ZodNumber>;
+            drainOnVersionUpgrade: z$1.ZodOptional<z$1.ZodBoolean>;
+        }, z$1.core.$strip>>>;
+        basePath: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodString>>;
+        publicEndpoint: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+        publicToken: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+    }, z$1.core.$strip>>>;
+    runner: z$1.ZodDefault<z$1.ZodOptional<z$1.ZodObject<{
+        totalSlots: z$1.ZodDefault<z$1.ZodNumber>;
+        runnerName: z$1.ZodDefault<z$1.ZodString>;
+        runnerKey: z$1.ZodPipe<z$1.ZodOptional<z$1.ZodString>, z$1.ZodTransform<string | undefined, string | undefined>>;
+        version: z$1.ZodDefault<z$1.ZodNumber>;
+    }, z$1.core.$strip>>>;
+}, z$1.core.$strip>, z$1.ZodTransform<{
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    serveManager: boolean;
+    publicEndpoint: string | undefined;
+    publicNamespace: string | undefined;
+    publicToken: string | undefined;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    } | {
+        enabled: {
+            manager: boolean;
+            actor: boolean;
+        };
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    serverless: {
+        publicEndpoint: string | undefined;
+        spawnEngine: boolean;
+        engineVersion: string;
+        basePath: string;
+        publicToken: string | undefined;
+        configureRunnerPool?: {
+            url: string;
+            name?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            maxRunners?: number | undefined;
+            minRunners?: number | undefined;
+            requestLifespan?: number | undefined;
+            runnersMargin?: number | undefined;
+            slotsPerRunner?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            metadataPollInterval?: number | undefined;
+            drainOnVersionUpgrade?: boolean | undefined;
+        } | undefined;
+    };
+    use: Record<string, AnyActorDefinition>;
+    test: {
+        enabled: boolean;
+    };
+    storagePath: string | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    headers: Record<string, string>;
+    managerBasePath: string;
+    managerPort: number;
+    runner: {
+        totalSlots: number;
+        runnerName: string;
+        runnerKey: string | undefined;
+        version: number;
+    };
+    driver?: {
+        name: string;
+        displayName: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+        autoStartActorDriver: boolean;
+    } | undefined;
+    managerHost?: string | undefined;
+}, {
+    use: Record<string, AnyActorDefinition>;
+    test: {
+        enabled: boolean;
+    };
+    storagePath: string | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    endpoint: string | undefined;
+    token: string | undefined;
+    namespace: string | undefined;
+    headers: Record<string, string>;
+    managerBasePath: string;
+    managerPort: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    serverless: {
+        spawnEngine: boolean;
+        engineVersion: string;
+        basePath: string;
+        publicEndpoint: string | undefined;
+        publicToken: string | undefined;
+        configureRunnerPool?: {
+            url: string;
+            name?: string | undefined;
+            headers?: Record<string, string> | undefined;
+            maxRunners?: number | undefined;
+            minRunners?: number | undefined;
+            requestLifespan?: number | undefined;
+            runnersMargin?: number | undefined;
+            slotsPerRunner?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+            metadataPollInterval?: number | undefined;
+            drainOnVersionUpgrade?: boolean | undefined;
+        } | undefined;
+    };
+    runner: {
+        totalSlots: number;
+        runnerName: string;
+        runnerKey: string | undefined;
+        version: number;
+    };
+    driver?: {
+        name: string;
+        displayName: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+        autoStartActorDriver: boolean;
+    } | undefined;
+    serveManager?: boolean | undefined;
+    managerHost?: string | undefined;
+}>>;
+type RegistryConfig = z$1.infer<typeof RegistryConfigSchema>;
+type RegistryConfigInput<A extends RegistryActors> = Omit<z$1.input<typeof RegistryConfigSchema>, "use"> & {
+    use: A;
+};
+
+type AnyActorDefinition = ActorDefinition<any, any, any, any, any, any, any, any, any>;
+declare class ActorDefinition<S, CP, CS, V, I, DB extends AnyDatabaseProvider, E extends EventSchemaConfig = Record<never, never>, Q extends QueueSchemaConfig = Record<never, never>, R extends Actions<S, CP, CS, V, I, DB, E, Q> = Actions<S, CP, CS, V, I, DB, E, Q>> {
+    #private;
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB, E, Q>);
+    get config(): ActorConfig<S, CP, CS, V, I, DB, E, Q>;
+    instantiate(): ActorInstance<S, CP, CS, V, I, DB, E, Q>;
+}
+
+/**
+ * Action function returned by Actor connections and handles.
+ *
+ * @typedef {Function} ActorActionFunction
+ * @template Args
+ * @template Response
+ * @param {...Args} args - Arguments for the action function.
+ * @returns {Promise<Response>}
+ */
+type ActorActionFunction<Args extends Array<unknown> = unknown[], Response = unknown> = (...args: Args extends [unknown, ...infer Rest] ? Rest : Args) => Promise<Response>;
+/**
+ * Maps action methods from actor definition to typed function signatures.
+ */
+type ActorDefinitionActions<AD extends AnyActorDefinition> = AD extends ActorDefinition<any, any, any, any, any, any, any, any, infer R> ? {
+    [K in keyof R]: R[K] extends (...args: infer Args) => infer Return ? ActorActionFunction<Args, Return> : never;
+} : never;
+
+declare class ActorClientError extends Error {
+}
+declare class InternalError extends ActorClientError {
+}
+declare class ManagerError extends ActorClientError {
+    constructor(error: string, opts?: ErrorOptions);
+}
+declare class MalformedResponseMessage extends ActorClientError {
+    constructor(cause?: unknown);
+}
+declare class ActorError extends ActorClientError {
+    readonly group: string;
+    readonly code: string;
+    readonly metadata?: unknown | undefined;
+    __type: string;
+    constructor(group: string, code: string, message: string, metadata?: unknown | undefined);
+}
+declare class ActorConnDisposed extends ActorClientError {
+    constructor();
+}
+
+interface QueueSendWaitOptions {
+    wait: true;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+interface QueueSendNoWaitOptions {
+    wait?: false;
+    timeout?: never;
+    signal?: AbortSignal;
+}
+interface QueueSendResult {
+    status: "completed" | "timedOut";
+    response?: unknown;
+}
+
+/**
+ * Connection status for an actor connection.
+ *
+ * - `"idle"`: Not connected, no auto-reconnect (initial state, after dispose, or disabled)
+ * - `"connecting"`: Attempting to establish connection
+ * - `"connected"`: Connection is active
+ * - `"disconnected"`: Connection was lost, will auto-reconnect
+ */
+type ActorConnStatus = "idle" | "connecting" | "connected" | "disconnected";
+/**
+ * A function that unsubscribes from an event.
+ *
+ * @typedef {Function} EventUnsubscribe
+ */
+type EventUnsubscribe = () => void;
+/**
+ * A function that handles connection errors.
+ *
+ * @typedef {Function} ActorErrorCallback
+ */
+type ActorErrorCallback = (error: ActorError) => void;
+/**
+ * A callback for connection state changes.
+ *
+ * @typedef {Function} ConnectionStateCallback
+ */
+type ConnectionStateCallback = () => void;
+/**
+ * A callback for connection status changes.
+ *
+ * @typedef {Function} StatusChangeCallback
+ */
+type StatusChangeCallback = (status: ActorConnStatus) => void;
+declare const CONNECT_SYMBOL: unique symbol;
+/**
+ * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.
+ *
+ * @see {@link ActorConn}
+ */
+declare class ActorConnRaw {
+    #private;
+    /**
+     * Do not call this directly.
+     *
+     * Creates an instance of ActorConnRaw.
+     *
+     * @protected
+     */
+    constructor(client: ClientRaw, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
+    /**
+     * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
+     *
+     * @see {@link ActorConn}
+     * @template Args - The type of arguments to pass to the action function.
+     * @template Response - The type of the response returned by the action function.
+     * @param {string} name - The name of the action function to call.
+     * @param {...Args} args - The arguments to pass to the action function.
+     * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+     */
+    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
+        name: string;
+        args: Args;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    /**
+     * Do not call this directly.
+     * Establishes a connection to the server using the specified endpoint & encoding & driver.
+     *
+     * @protected
+     */
+    [CONNECT_SYMBOL](): void;
+    /**
+     * Subscribes to an event that will happen repeatedly.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     */
+    on<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    /**
+     * Subscribes to an event that will be triggered only once.
+     *
+     * @template Args - The type of arguments the event callback will receive.
+     * @param {string} eventName - The name of the event to subscribe to.
+     * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+     * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+     * @see {@link https://rivet.dev/docs/events|Events Documentation}
+     */
+    once<Args extends Array<unknown> = unknown[]>(eventName: string, callback: (...args: Args) => void): EventUnsubscribe;
+    /**
+     * Subscribes to connection errors.
+     *
+     * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
+     * @returns {() => void} - A function to unsubscribe from the error handler.
+     */
+    onError(callback: ActorErrorCallback): () => void;
+    /**
+     * Returns the current connection status.
+     *
+     * @returns {ActorConnStatus} - The current connection status.
+     */
+    get connStatus(): ActorConnStatus;
+    /**
+     * Returns whether the connection is currently open.
+     *
+     * @deprecated Use `connStatus` instead.
+     * @returns {boolean} - True if the connection is open, false otherwise.
+     */
+    get isConnected(): boolean;
+    /**
+     * Subscribes to connection open events.
+     *
+     * This is called when the WebSocket connection is established and the Init message is received.
+     *
+     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection opens.
+     * @returns {() => void} - A function to unsubscribe from the open handler.
+     */
+    onOpen(callback: ConnectionStateCallback): () => void;
+    /**
+     * Subscribes to connection close events.
+     *
+     * This is called when the WebSocket connection is closed. The connection will automatically
+     * attempt to reconnect unless disposed.
+     *
+     * @param {ConnectionStateCallback} callback - The callback function to execute when the connection closes.
+     * @returns {() => void} - A function to unsubscribe from the close handler.
+     */
+    onClose(callback: ConnectionStateCallback): () => void;
+    /**
+     * Subscribes to connection status changes.
+     *
+     * This is called whenever the connection status changes between Disconnected, Connecting, and Connected.
+     *
+     * @param {StatusChangeCallback} callback - The callback function to execute when the status changes.
+     * @returns {() => void} - A function to unsubscribe from the status change handler.
+     */
+    onStatusChange(callback: StatusChangeCallback): () => void;
+    /**
+     * Disconnects from the actor.
+     *
+     * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Connection to a actor. Allows calling actor's remote procedure calls with inferred types. See {@link ActorConnRaw} for underlying methods.
+ *
+ * @example
+ * ```
+ * const room = client.connect<ChatRoom>(...etc...);
+ * // This calls the action named `sendMessage` on the `ChatRoom` actor.
+ * await room.sendMessage('Hello, world!');
+ * ```
+ *
+ * Private methods (e.g. those starting with `_`) are automatically excluded.
+ *
+ * @template AD The actor class that this connection is for.
+ * @see {@link ActorConnRaw}
+ */
+type ActorConn<AD extends AnyActorDefinition> = ActorConnRaw & ActorDefinitionActions<AD>;
+
+/**
+ * Provides underlying functions for stateless {@link ActorHandle} for action calls.
+ * Similar to ActorConnRaw but doesn't maintain a connection.
+ *
+ * @see {@link ActorHandle}
+ */
+declare class ActorHandleRaw {
+    #private;
+    /**
+     * Do not call this directly.
+     *
+     * Creates an instance of ActorHandleRaw.
+     *
+     * @protected
+     */
+    constructor(client: any, driver: ManagerDriver, params: unknown, encoding: Encoding, actorQuery: ActorQuery);
+    send(name: string, body: unknown, options: QueueSendWaitOptions): Promise<QueueSendResult>;
+    send(name: string, body: unknown, options?: QueueSendNoWaitOptions): Promise<void>;
+    /**
+     * Call a raw action. This method sends an HTTP request to invoke the named action.
+     *
+     * @see {@link ActorHandle}
+     * @template Args - The type of arguments to pass to the action function.
+     * @template Response - The type of the response returned by the action function.
+     */
+    action<Args extends Array<unknown> = unknown[], Response = unknown>(opts: {
+        name: string;
+        args: Args;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    /**
+     * Establishes a persistent connection to the actor.
+     *
+     * @template AD The actor class that this connection is for.
+     * @returns {ActorConn<AD>} A connection to the actor.
+     */
+    connect(): ActorConn<AnyActorDefinition>;
+    /**
+     * Fetches a resource from this actor via the /request endpoint. This is a
+     * convenience wrapper around the raw HTTP API.
+     */
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    /**
+     * Opens a raw WebSocket connection to this actor.
+     */
+    webSocket(path?: string, protocols?: string | string[]): Promise<any>;
+    /**
+     * Resolves the actor to get its unique actor ID.
+     */
+    resolve(): Promise<string>;
+    /**
+     * Returns the raw URL for routing traffic to the actor.
+     */
+    getGatewayUrl(): Promise<string>;
+}
+/**
+ * Stateless handle to a actor. Allows calling actor's remote procedure calls with inferred types
+ * without establishing a persistent connection.
+ *
+ * @example
+ * ```
+ * const room = client.get<ChatRoom>(...etc...);
+ * // This calls the action named `sendMessage` on the `ChatRoom` actor without a connection.
+ * await room.sendMessage('Hello, world!');
+ * ```
+ *
+ * Private methods (e.g. those starting with `_`) are automatically excluded.
+ *
+ * @template AD The actor class that this handle is for.
+ * @see {@link ActorHandleRaw}
+ */
+type ActorHandle<AD extends AnyActorDefinition> = Omit<ActorHandleRaw, "connect"> & {
+    connect(): ActorConn<AD>;
+    resolve(): Promise<string>;
+} & ActorDefinitionActions<AD>;
+
+declare const ClientConfigSchema: z$2.ZodPipe<z$2.ZodObject<{
+    endpoint: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string, string | undefined>>;
+    token: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
+    namespace: z$2.ZodPipe<z$2.ZodOptional<z$2.ZodString>, z$2.ZodTransform<string | undefined, string | undefined>>;
+    runnerName: z$2.ZodDefault<z$2.ZodString>;
+    encoding: z$2.ZodDefault<z$2.ZodEnum<{
+        json: "json";
+        cbor: "cbor";
+        bare: "bare";
+    }>>;
+    headers: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodRecord<z$2.ZodString, z$2.ZodString>>>;
+    getUpgradeWebSocket: z$2.ZodOptional<z$2.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
+    disableMetadataLookup: z$2.ZodDefault<z$2.ZodOptional<z$2.ZodBoolean>>;
+    devtools: z$2.ZodDefault<z$2.ZodBoolean>;
+}, z$2.core.$strip>, z$2.ZodTransform<{
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}, {
+    endpoint: string;
+    token: string | undefined;
+    namespace: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}>>;
+type ClientConfigInput = z$2.input<typeof ClientConfigSchema>;
+
+/** Extract the actor registry from the registry definition. */
+type ExtractActorsFromRegistry<A extends Registry<any>> = A extends Registry<infer Actors> ? Actors : never;
+/** Extract the registry definition from the client. */
+type ExtractRegistryFromClient<C extends Client<Registry<{}>>> = C extends Client<infer A> ? A : never;
+/**
+ * Represents a actor accessor that provides methods to interact with a specific actor.
+ */
+interface ActorAccessor<AD extends AnyActorDefinition> {
+    /**
+     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+     * The actor name is automatically injected from the property accessor.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    get(key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its key, creating it if necessary.
+     * The actor name is automatically injected from the property accessor.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    getOrCreate(key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its ID.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} actorId - The ID of the actor.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    getForId(actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Creates a new actor with the name automatically injected from the property accessor,
+     * and returns a stateless handle to it with the actor ID resolved.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+     */
+    create(key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
+}
+/**
+ * Options for querying actors.
+ * @typedef {Object} QueryOptions
+ * @property {unknown} [parameters] - Parameters to pass to the connection.
+ */
+interface QueryOptions {
+    /** Parameters to pass to the connection. */
+    params?: unknown;
+    /** Signal to abort the request. */
+    signal?: AbortSignal;
+}
+/**
+ * Options for getting a actor by ID.
+ * @typedef {QueryOptions} GetWithIdOptions
+ */
+interface GetWithIdOptions extends QueryOptions {
+}
+/**
+ * Options for getting a actor.
+ * @typedef {QueryOptions} GetOptions
+ */
+interface GetOptions extends QueryOptions {
+}
+/**
+ * Options for getting or creating a actor.
+ * @typedef {QueryOptions} GetOrCreateOptions
+ * @property {string} [createInRegion] - Region to create the actor in if it doesn't exist.
+ */
+interface GetOrCreateOptions extends QueryOptions {
+    /** Region to create the actor in if it doesn't exist. */
+    createInRegion?: string;
+    /** Input data to pass to the actor. */
+    createWithInput?: unknown;
+}
+/**
+ * Options for creating a actor.
+ * @typedef {QueryOptions} CreateOptions
+ * @property {string} [region] - The region to create the actor in.
+ */
+interface CreateOptions extends QueryOptions {
+    /** The region to create the actor in. */
+    region?: string;
+    /** Input data to pass to the actor. */
+    input?: unknown;
+}
+/**
+ * Represents a region to connect to.
+ * @typedef {Object} Region
+ * @property {string} id - The region ID.
+ * @property {string} name - The region name.
+ * @see {@link https://rivet.dev/docs/edge|Edge Networking}
+ * @see {@link https://rivet.dev/docs/regions|Available Regions}
+ */
+interface Region {
+    /**
+     * The region slug.
+     */
+    id: string;
+    /**
+     * The human-friendly region name.
+     */
+    name: string;
+}
+declare const ACTOR_CONNS_SYMBOL: unique symbol;
+declare const CREATE_ACTOR_CONN_PROXY: unique symbol;
+/**
+ * Client for managing & connecting to actors.
+ *
+ * @template A The actors map type that defines the available actors.
+ * @see {@link https://rivet.dev/docs/manage|Create & Manage Actors}
+ */
+declare class ClientRaw {
+    #private;
+    [ACTOR_CONNS_SYMBOL]: Set<ActorConnRaw>;
+    /**
+     * Creates an instance of Client.
+     */
+    constructor(driver: ManagerDriver, encoding: Encoding | undefined);
+    /**
+     * Gets a stateless handle to a actor by its ID.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string} actorId - The ID of the actor.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    getForId<AD extends AnyActorDefinition>(name: string, actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    get<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;
+    /**
+     * Gets a stateless handle to a actor by its key, creating it if necessary.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {GetOptions} [opts] - Options for getting the actor.
+     * @returns {ActorHandle<AD>} - A handle to the actor.
+     */
+    getOrCreate<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: GetOrCreateOptions): ActorHandle<AD>;
+    /**
+     * Creates a new actor with the provided key and returns a stateless handle to it.
+     * Resolves the actor ID and returns a handle with getForId query.
+     *
+     * @template AD The actor class that this handle is for.
+     * @param {string} name - The name of the actor.
+     * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+     * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+     * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+     */
+    create<AD extends AnyActorDefinition>(name: string, key?: string | string[], opts?: CreateOptions): Promise<ActorHandle<AD>>;
+    [CREATE_ACTOR_CONN_PROXY]<AD extends AnyActorDefinition>(conn: ActorConnRaw): ActorConn<AD>;
+    /**
+     * Disconnects from all actors.
+     *
+     * @returns {Promise<void>} A promise that resolves when all connections are closed.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Client type with actor accessors.
+ * This adds property accessors for actor names to the ClientRaw base class.
+ *
+ * @template A The actor registry type.
+ */
+type Client<A extends Registry<any>> = ClientRaw & {
+    [K in keyof ExtractActorsFromRegistry<A>]: ActorAccessor<ExtractActorsFromRegistry<A>[K]>;
+};
+type AnyClient = Client<Registry<any>>;
+
+declare const LegacyRunnerConfigSchema: z.ZodDefault<z.ZodPipe<z.ZodObject<{
+    driver: z.ZodOptional<z.ZodObject<{
+        name: z.ZodString;
+        manager: z.ZodCustom<ManagerDriverBuilder, ManagerDriverBuilder>;
+        actor: z.ZodCustom<ActorDriverBuilder, ActorDriverBuilder>;
+    }, z.core.$strip>>;
+    maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxOutgoingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    inspector: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        token: z.ZodDefault<z.ZodOptional<z.ZodCustom<() => string, () => string>>>;
+        defaultEndpoint: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    disableDefaultServer: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    defaultServerPort: z.ZodDefault<z.ZodNumber>;
+    runEngine: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    runEngineVersion: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    overrideServerAddress: z.ZodOptional<z.ZodString>;
+    disableActorDriver: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    runnerKind: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        serverless: "serverless";
+        normal: "normal";
+    }>>>;
+    basePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    noWelcome: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logging: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        baseLogger: z.ZodOptional<z.ZodCustom<Logger, Logger>>;
+        level: z.ZodOptional<z.ZodEnum<{
+            error: "error";
+            trace: "trace";
+            fatal: "fatal";
+            warn: "warn";
+            info: "info";
+            debug: "debug";
+            silent: "silent";
+        }>>;
+    }, z.core.$strip>>>;
+    autoConfigureServerless: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        maxRunners: z.ZodOptional<z.ZodNumber>;
+        minRunners: z.ZodOptional<z.ZodNumber>;
+        requestLifespan: z.ZodOptional<z.ZodNumber>;
+        runnersMargin: z.ZodOptional<z.ZodNumber>;
+        slotsPerRunner: z.ZodOptional<z.ZodNumber>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>]>>;
+    endpoint: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string, string | undefined>>;
+    token: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    namespace: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    runnerName: z.ZodDefault<z.ZodString>;
+    encoding: z.ZodDefault<z.ZodEnum<{
+        json: "json";
+        cbor: "cbor";
+        bare: "bare";
+    }>>;
+    headers: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+    getUpgradeWebSocket: z.ZodOptional<z.ZodCustom<GetUpgradeWebSocket, GetUpgradeWebSocket>>;
+    disableMetadataLookup: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    devtools: z.ZodDefault<z.ZodBoolean>;
+    runnerKey: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string | undefined, string | undefined>>;
+    totalSlots: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, z.ZodTransform<{
+    runnerKey: string | undefined;
+    endpoint: string | undefined;
+    namespace: string;
+    token: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    disableDefaultServer: boolean;
+    defaultServerPort: number;
+    runEngine: boolean;
+    runEngineVersion: string;
+    disableActorDriver: boolean;
+    runnerKind: "serverless" | "normal";
+    basePath: string;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    totalSlots: number;
+    driver?: {
+        name: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+    } | undefined;
+    overrideServerAddress?: string | undefined;
+    autoConfigureServerless?: boolean | {
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        maxRunners?: number | undefined;
+        minRunners?: number | undefined;
+        requestLifespan?: number | undefined;
+        runnersMargin?: number | undefined;
+        slotsPerRunner?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+}, {
+    maxIncomingMessageSize: number;
+    maxOutgoingMessageSize: number;
+    inspector: {
+        enabled: boolean;
+        token: () => string;
+        defaultEndpoint?: string | undefined;
+    };
+    disableDefaultServer: boolean;
+    defaultServerPort: number;
+    runEngine: boolean;
+    runEngineVersion: string;
+    disableActorDriver: boolean;
+    runnerKind: "serverless" | "normal";
+    basePath: string;
+    noWelcome: boolean;
+    logging: {
+        baseLogger?: Logger | undefined;
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+    };
+    endpoint: string;
+    token: string | undefined;
+    namespace: string | undefined;
+    runnerName: string;
+    encoding: "json" | "cbor" | "bare";
+    headers: Record<string, string>;
+    disableMetadataLookup: boolean;
+    devtools: boolean;
+    runnerKey: string | undefined;
+    totalSlots: number;
+    driver?: {
+        name: string;
+        manager: ManagerDriverBuilder;
+        actor: ActorDriverBuilder;
+    } | undefined;
+    overrideServerAddress?: string | undefined;
+    autoConfigureServerless?: boolean | {
+        url?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        maxRunners?: number | undefined;
+        minRunners?: number | undefined;
+        requestLifespan?: number | undefined;
+        runnersMargin?: number | undefined;
+        slotsPerRunner?: number | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    } | undefined;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}>>>;
+type LegacyRunnerConfigInput = z.input<typeof LegacyRunnerConfigSchema>;
+
+type FetchHandler = (request: Request, ...args: any) => Response | Promise<Response>;
+interface ServerlessHandler {
+    fetch: FetchHandler;
+}
+interface LegacyStartServerOutput<A extends Registry<any>> {
+    /** Client to communicate with the actors. */
+    client: Client<A>;
+    /** Fetch handler to manually route requests to the Rivet manager API. */
+    fetch: FetchHandler;
+}
+declare class Registry<A extends RegistryActors> {
+    #private;
+    get config(): RegistryConfigInput<A>;
+    parseConfig(): RegistryConfig;
+    constructor(config: RegistryConfigInput<A>);
+    /**
+     * Handle an incoming HTTP request for serverless deployments.
+     *
+     * @example
+     * ```ts
+     * const app = new Hono();
+     * app.all("/api/rivet/*", (c) => registry.handler(c.req.raw));
+     * export default app;
+     * ```
+     */
+    handler(request: Request): Promise<Response>;
+    /**
+     * Returns a fetch handler for serverless deployments.
+     *
+     * @example
+     * ```ts
+     * export default registry.serve();
+     * ```
+     */
+    serve(): ServerlessHandler;
+    /**
+     * Starts an actor runner for standalone server deployments.
+     */
+    startRunner(): void;
+    /**
+     * Runs the registry for a server.
+     *
+     * @deprecated Use {@link Registry.startRunner} for long-running servers or {@link Registry.handler} for serverless deployments.
+     */
+    start(inputConfig?: LegacyRunnerConfigInput): LegacyStartServerOutput<this>;
+}
+
+/**
+ * Creates a client with the actor accessor proxy.
+ */
+declare function createClient<A extends Registry<any>>(endpointOrConfig?: string | ClientConfigInput): Client<A>;
+
+export { type ActorAccessor, type ActorActionFunction, ActorClientError, type ActorConn, ActorConnDisposed, ActorConnRaw, type ActorConnStatus, ActorDefinition, ActorError, type ActorHandle, ActorHandleRaw, type AnyActorDefinition, type Client, ClientRaw, type ConnectionStateCallback, type CreateOptions, type CreateRequest, type Encoding, type EventUnsubscribe, type ExtractActorsFromRegistry, type ExtractRegistryFromClient, type GetOptions, type GetWithIdOptions, InternalError, KEYS as KV_KEYS, MalformedResponseMessage, ManagerError, type QueryOptions, type Region, type StatusChangeCallback, createClient };