rivetkit 2.0.2 → 2.0.4

package/dist/tsup/connection-Dyd4NLGW.d.cts

@@ -0,0 +1,2087 @@
+import z$1, { z } from 'zod';
+import { Logger } from 'pino';
+import * as hono from 'hono';
+import { Env, Context, Hono } from 'hono';
+import { UpgradeWebSocket } from './utils.cjs';
+import * as nanoevents from 'nanoevents';
+import { g as Connection, h as RealtimeEvent } from './common-CXCe7s6i.cjs';
+import { SSEStreamingApi } from 'hono/streaming';
+import { WSContext } from 'hono/ws';
+
+type uint = bigint;
+type Init = {
+    readonly actorId: string;
+    readonly connectionId: string;
+    readonly connectionToken: string;
+};
+type Error$1 = {
+    readonly group: string;
+    readonly code: string;
+    readonly message: string;
+    readonly metadata: ArrayBuffer | null;
+    readonly actionId: uint | null;
+};
+type ActionResponse = {
+    readonly id: uint;
+    readonly output: ArrayBuffer;
+};
+type Event = {
+    readonly name: string;
+    readonly args: ArrayBuffer;
+};
+type ToClientBody = {
+    readonly tag: "Init";
+    readonly val: Init;
+} | {
+    readonly tag: "Error";
+    readonly val: Error$1;
+} | {
+    readonly tag: "ActionResponse";
+    readonly val: ActionResponse;
+} | {
+    readonly tag: "Event";
+    readonly val: Event;
+};
+type ToClient = {
+    readonly body: ToClientBody;
+};
+type ActionRequest = {
+    readonly id: uint;
+    readonly name: string;
+    readonly args: ArrayBuffer;
+};
+type SubscriptionRequest = {
+    readonly eventName: string;
+    readonly subscribe: boolean;
+};
+type ToServerBody = {
+    readonly tag: "ActionRequest";
+    readonly val: ActionRequest;
+} | {
+    readonly tag: "SubscriptionRequest";
+    readonly val: SubscriptionRequest;
+};
+type ToServer = {
+    readonly body: ToServerBody;
+};
+
+type InferDatabaseClient<DBProvider extends AnyDatabaseProvider> = DBProvider extends DatabaseProvider<any> ? Awaited<ReturnType<DBProvider["createClient"]>> : never;
+type AnyDatabaseProvider = DatabaseProvider<any> | undefined;
+type DatabaseProvider<DB extends {
+    execute: (query: string) => any;
+}> = {
+    /**
+     * Creates a new database client for the actor.
+     * The result is passed to the actor context as `c.db`.
+     * @experimental
+     */
+    createClient: (ctx: {
+        getDatabase: () => Promise<string | unknown>;
+    }) => Promise<DB>;
+    /**
+     * Runs before the actor has started.
+     * Use this to run migrations or other setup tasks.
+     * @experimental
+     */
+    onMigrate: (client: DB) => void | Promise<void>;
+};
+
+type MigrationFn<TFrom, TTo> = (data: TFrom) => TTo;
+interface VersionedDataConfig<T> {
+    currentVersion: number;
+    migrations: Map<number, MigrationFn<any, any>>;
+    serializeVersion: (data: T) => Uint8Array;
+    deserializeVersion: (bytes: Uint8Array) => T;
+}
+declare class VersionedDataHandler<T> {
+    private config;
+    constructor(config: VersionedDataConfig<T>);
+    serializeWithEmbeddedVersion(data: T): Uint8Array;
+    deserializeWithEmbeddedVersion(bytes: Uint8Array): T;
+    serialize(data: T, version: number): Uint8Array;
+    deserialize(bytes: Uint8Array, version: number): T;
+    private embedVersion;
+    private extractVersion;
+}
+
+/** Data that's been serialized. */
+type OutputData = string | Uint8Array;
+declare const EncodingSchema: z.ZodEnum<["json", "cbor", "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<T> {
+    #private;
+    constructor(data: T, versionedDataHandler: VersionedDataHandler<T>);
+    get rawData(): T;
+    serialize(encoding: Encoding): OutputData;
+}
+
+declare const ActorsSchema: z.ZodRecord<z.ZodString, z.ZodType<ActorDefinition<any, any, any, any, any, any, any>, z.ZodTypeDef, ActorDefinition<any, any, any, any, any, any, any>>>;
+type RegistryActors = z.infer<typeof ActorsSchema>;
+/** Base config used for the actor config across all platforms. */
+declare const RegistryConfigSchema: z.ZodObject<{
+    use: z.ZodRecord<z.ZodString, z.ZodType<AnyActorDefinition, z.ZodTypeDef, AnyActorDefinition>>;
+    /**
+     * Test configuration.
+     *
+     * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
+     * @internal
+     **/
+    test: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+    }, {
+        enabled: boolean;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    use: Record<string, AnyActorDefinition>;
+    test: {
+        enabled: boolean;
+    };
+}, {
+    use: Record<string, AnyActorDefinition>;
+    test?: {
+        enabled: boolean;
+    } | undefined;
+}>;
+type RegistryConfig = z.infer<typeof RegistryConfigSchema>;
+type RegistryConfigInput<A extends RegistryActors> = Omit<z.input<typeof RegistryConfigSchema>, "use"> & {
+    use: A;
+};
+
+interface RivetEvent {
+    type: string;
+    target?: any;
+    currentTarget?: any;
+}
+interface RivetMessageEvent extends RivetEvent {
+    data: any;
+}
+interface RivetCloseEvent extends RivetEvent {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+}
+/**
+ * Common WebSocket interface that can be implemented by different WebSocket-like classes
+ * This is compatible with the standard WebSocket API but allows for custom implementations
+ */
+interface UniversalWebSocket {
+    readonly CONNECTING: 0;
+    readonly OPEN: 1;
+    readonly CLOSING: 2;
+    readonly CLOSED: 3;
+    readonly readyState: 0 | 1 | 2 | 3;
+    binaryType: "arraybuffer" | "blob";
+    readonly bufferedAmount: number;
+    readonly extensions: string;
+    readonly protocol: string;
+    readonly url: string;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: string, listener: (event: any) => void): void;
+    removeEventListener(type: string, listener: (event: any) => void): void;
+    dispatchEvent(event: RivetEvent): boolean;
+    onopen?: ((event: RivetEvent) => void) | null;
+    onclose?: ((event: RivetCloseEvent) => void) | null;
+    onerror?: ((event: RivetEvent) => void) | null;
+    onmessage?: ((event: RivetMessageEvent) => void) | null;
+}
+
+type GetUpgradeWebSocket = () => UpgradeWebSocket;
+declare const ClientConfigSchema: z$1.ZodObject<{
+    /** Configure serving the API */
+    api: z$1.ZodDefault<z$1.ZodObject<{
+        host: z$1.ZodDefault<z$1.ZodString>;
+        port: z$1.ZodDefault<z$1.ZodNumber>;
+    }, "strip", z$1.ZodTypeAny, {
+        host: string;
+        port: number;
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+    }>>;
+    /** Endpoint to connect to the Rivet engine. Can be configured via RIVET_ENGINE env var. */
+    endpoint: z$1.ZodDefault<z$1.ZodNullable<z$1.ZodString>>;
+    namespace: z$1.ZodDefault<z$1.ZodString>;
+    runnerName: z$1.ZodDefault<z$1.ZodString>;
+    encoding: z$1.ZodDefault<z$1.ZodEnum<["json", "cbor", "bare"]>>;
+    transport: z$1.ZodDefault<z$1.ZodEnum<["websocket", "sse"]>>;
+    getUpgradeWebSocket: z$1.ZodOptional<z$1.ZodType<GetUpgradeWebSocket, z$1.ZodTypeDef, GetUpgradeWebSocket>>;
+}, "strip", z$1.ZodTypeAny, {
+    encoding: "json" | "cbor" | "bare";
+    api: {
+        host: string;
+        port: number;
+    };
+    endpoint: string | null;
+    namespace: string;
+    runnerName: string;
+    transport: "websocket" | "sse";
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}, {
+    encoding?: "json" | "cbor" | "bare" | undefined;
+    api?: {
+        host?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    endpoint?: string | null | undefined;
+    namespace?: string | undefined;
+    runnerName?: string | undefined;
+    transport?: "websocket" | "sse" | undefined;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}>;
+type ClientConfig = z$1.infer<typeof ClientConfigSchema>;
+type ClientConfigInput = z$1.input<typeof ClientConfigSchema>;
+
+type ManagerDriverBuilder = (registryConfig: RegistryConfig, runConfig: RunConfig) => 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>;
+    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, authData: unknown): Promise<Response>;
+    displayInformation(): ManagerDisplayInformation;
+    extraStartupLog?: () => Record<string, unknown>;
+    modifyManagerRouter?: (registryConfig: RegistryConfig, router: Hono) => void;
+}
+interface ManagerDisplayInformation {
+    name: string;
+    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 ActorOutput {
+    actorId: string;
+    name: string;
+    key: ActorKey;
+}
+
+declare const DriverConfigSchema: z.ZodObject<{
+    /** Machine-readable name to identify this driver by. */
+    name: z.ZodString;
+    manager: z.ZodType<ManagerDriverBuilder, z.ZodTypeDef, ManagerDriverBuilder>;
+    actor: z.ZodType<ActorDriverBuilder, z.ZodTypeDef, ActorDriverBuilder>;
+}, "strip", z.ZodTypeAny, {
+    actor: ActorDriverBuilder;
+    name: string;
+    manager: ManagerDriverBuilder;
+}, {
+    actor: ActorDriverBuilder;
+    name: string;
+    manager: ManagerDriverBuilder;
+}>;
+type DriverConfig = z.infer<typeof DriverConfigSchema>;
+/** Base config used for the actor config across all platforms. */
+declare const RunConfigSchema: z.ZodDefault<z.ZodObject<{
+    api: z.ZodDefault<z.ZodObject<{
+        host: z.ZodDefault<z.ZodString>;
+        port: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        host: string;
+        port: number;
+    }, {
+        host?: string | undefined;
+        port?: number | undefined;
+    }>>;
+    endpoint: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    namespace: z.ZodDefault<z.ZodString>;
+    runnerName: z.ZodDefault<z.ZodString>;
+    encoding: z.ZodDefault<z.ZodEnum<["json", "cbor", "bare"]>>;
+    transport: z.ZodDefault<z.ZodEnum<["websocket", "sse"]>>;
+    getUpgradeWebSocket: z.ZodOptional<z.ZodType<GetUpgradeWebSocket, z.ZodTypeDef, GetUpgradeWebSocket>>;
+} & {
+    driver: z.ZodOptional<z.ZodObject<{
+        /** Machine-readable name to identify this driver by. */
+        name: z.ZodString;
+        manager: z.ZodType<ManagerDriverBuilder, z.ZodTypeDef, ManagerDriverBuilder>;
+        actor: z.ZodType<ActorDriverBuilder, z.ZodTypeDef, ActorDriverBuilder>;
+    }, "strip", z.ZodTypeAny, {
+        actor: ActorDriverBuilder;
+        name: string;
+        manager: ManagerDriverBuilder;
+    }, {
+        actor: ActorDriverBuilder;
+        name: string;
+        manager: ManagerDriverBuilder;
+    }>>;
+    /** CORS configuration for the router. Uses Hono's CORS middleware options. */
+    cors: z.ZodOptional<z.ZodType<{
+        origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+        allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    }, z.ZodTypeDef, {
+        origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+        allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    }>>;
+    maxIncomingMessageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    inspector: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        cors: z.ZodDefault<z.ZodOptional<z.ZodType<{
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        }, z.ZodTypeDef, {
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        }>>>;
+        token: z.ZodDefault<z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodString>>>;
+        defaultEndpoint: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        cors: {
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        };
+        token: (...args: unknown[]) => string;
+        defaultEndpoint?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        cors?: {
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        } | undefined;
+        token?: ((...args: unknown[]) => string) | undefined;
+        defaultEndpoint?: string | undefined;
+    }>>>;
+    /**
+     * Base path for the router. This is used to prefix all routes.
+     * For example, if the base path is `/api`, then the route `/actors` will be
+     * available at `/api/actors`.
+     */
+    basePath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Disable welcome message. */
+    noWelcome: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    logging: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        baseLogger: z.ZodOptional<z.ZodType<Logger, z.ZodTypeDef, Logger>>;
+        level: z.ZodOptional<z.ZodEnum<["trace", "debug", "info", "warn", "error", "fatal", "silent"]>>;
+    }, "strip", z.ZodTypeAny, {
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+        baseLogger?: Logger | undefined;
+    }, {
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+        baseLogger?: Logger | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    encoding: "json" | "cbor" | "bare";
+    inspector: {
+        enabled: boolean;
+        cors: {
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        };
+        token: (...args: unknown[]) => string;
+        defaultEndpoint?: string | undefined;
+    };
+    api: {
+        host: string;
+        port: number;
+    };
+    endpoint: string | null;
+    namespace: string;
+    runnerName: string;
+    transport: "websocket" | "sse";
+    maxIncomingMessageSize: number;
+    basePath: string;
+    noWelcome: boolean;
+    logging: {
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+        baseLogger?: Logger | undefined;
+    };
+    driver?: {
+        actor: ActorDriverBuilder;
+        name: string;
+        manager: ManagerDriverBuilder;
+    } | undefined;
+    cors?: {
+        origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+        allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    } | undefined;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+}, {
+    encoding?: "json" | "cbor" | "bare" | undefined;
+    driver?: {
+        actor: ActorDriverBuilder;
+        name: string;
+        manager: ManagerDriverBuilder;
+    } | undefined;
+    inspector?: {
+        enabled?: boolean | undefined;
+        cors?: {
+            origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+            allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+            allowHeaders?: string[];
+            maxAge?: number;
+            credentials?: boolean;
+            exposeHeaders?: string[];
+        } | undefined;
+        token?: ((...args: unknown[]) => string) | undefined;
+        defaultEndpoint?: string | undefined;
+    } | undefined;
+    cors?: {
+        origin: string | string[] | ((origin: string, c: hono.Context) => string | undefined | null);
+        allowMethods?: string[] | ((origin: string, c: hono.Context) => string[]);
+        allowHeaders?: string[];
+        maxAge?: number;
+        credentials?: boolean;
+        exposeHeaders?: string[];
+    } | undefined;
+    api?: {
+        host?: string | undefined;
+        port?: number | undefined;
+    } | undefined;
+    endpoint?: string | null | undefined;
+    namespace?: string | undefined;
+    runnerName?: string | undefined;
+    transport?: "websocket" | "sse" | undefined;
+    getUpgradeWebSocket?: GetUpgradeWebSocket | undefined;
+    maxIncomingMessageSize?: number | undefined;
+    basePath?: string | undefined;
+    noWelcome?: boolean | undefined;
+    logging?: {
+        level?: "error" | "trace" | "fatal" | "warn" | "info" | "debug" | "silent" | undefined;
+        baseLogger?: Logger | undefined;
+    } | undefined;
+}>>;
+type RunConfig = z.infer<typeof RunConfigSchema>;
+type RunConfigInput = z.input<typeof RunConfigSchema>;
+
+interface ServerOutput<A extends Registry<any>> {
+    config: RunConfig;
+    driver: DriverConfig;
+    client: Client<A>;
+    hono: Hono;
+    handler: (req: Request) => Promise<Response>;
+    serve: (hono?: Hono) => void;
+}
+declare class Registry<A extends RegistryActors> {
+    #private;
+    get config(): RegistryConfig;
+    constructor(config: RegistryConfig);
+    /**
+     * Runs the registry for a server.
+     */
+    createServer(inputConfig?: RunConfigInput): ServerOutput<this>;
+    /**
+     * Runs the registry as a standalone server.
+     */
+    runServer(inputConfig?: RunConfigInput): Promise<void>;
+}
+declare function setup<A extends RegistryActors>(input: RegistryConfigInput<A>): Registry<A>;
+
+interface ActorInspectorAccessors {
+    isStateEnabled: () => Promise<boolean>;
+    getState: () => Promise<unknown>;
+    setState: (state: unknown) => Promise<void>;
+    isDbEnabled: () => Promise<boolean>;
+    getDb: () => Promise<InferDatabaseClient<AnyDatabaseProvider>>;
+    getRpcs: () => Promise<string[]>;
+    getConnections: () => Promise<Connection[]>;
+}
+interface ActorInspectorEmitterEvents {
+    stateUpdated: (state: unknown) => void;
+    connectionUpdated: () => void;
+    eventFired: (event: RealtimeEvent) => void;
+}
+/**
+ * Provides a unified interface for inspecting actor external and internal state.
+ */
+declare class ActorInspector {
+    #private;
+    readonly accessors: ActorInspectorAccessors;
+    readonly emitter: nanoevents.Emitter<ActorInspectorEmitterEvents>;
+    get lastRealtimeEvents(): (({
+        type: "action";
+        name: string;
+        args: any[];
+        connId: string;
+    } | {
+        type: "broadcast";
+        eventName: string;
+        args: any[];
+    } | {
+        type: "subscribe";
+        eventName: string;
+        connId: string;
+    } | {
+        type: "unsubscribe";
+        eventName: string;
+        connId: string;
+    } | {
+        type: "event";
+        eventName: string;
+        args: any[];
+        connId: string;
+    }) & {
+        id: string;
+        timestamp: number;
+    })[];
+    constructor(accessors: () => ActorInspectorAccessors);
+}
+
+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>;
+}
+
+/**
+ * Options for the `_saveState` method.
+ */
+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;
+}
+/** Actor type alias with all `any` types. Used for `extends` in classes referencing this actor. */
+type AnyActorInstance = ActorInstance<any, any, any, any, any, any>;
+declare class ActorInstance<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
+    #private;
+    actorContext: ActorContext<S, CP, CS, V, I, DB>;
+    get isStopping(): boolean;
+    get id(): string;
+    get inlineClient(): Client<Registry<any>>;
+    get inspector(): ActorInspector;
+    /**
+     * This constructor should never be used directly.
+     *
+     * Constructed in {@link ActorInstance.start}.
+     *
+     * @private
+     */
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB>);
+    start(connectionDrivers: ConnectionDriversMap, actorDriver: ActorDriver, inlineClient: Client<Registry<any>>, actorId: string, name: string, key: ActorKey, region: string): Promise<void>;
+    _onAlarm(): Promise<void>;
+    scheduleEvent(timestamp: number, action: string, args: unknown[]): Promise<void>;
+    get stateEnabled(): boolean;
+    __getConnForId(id: string): Conn<S, CP, CS, V, I, DB> | undefined;
+    /**
+     * Removes a connection and cleans up its resources.
+     */
+    __removeConn(conn: Conn<S, CP, CS, V, I, DB> | undefined): void;
+    prepareConn(params: any, request?: Request): Promise<CS>;
+    __getConnDriver(driverId: ConnectionDriver): ConnDriver;
+    /**
+     * Called after establishing a connection handshake.
+     */
+    createConn(connectionId: string, connectionToken: string, params: CP, state: CS, driverId: ConnectionDriver, driverState: unknown, authData: unknown): Promise<Conn<S, CP, CS, V, I, DB>>;
+    processMessage(message: ToServer, conn: Conn<S, CP, CS, V, I, DB>): Promise<void>;
+    /**
+     * Check if the actor is ready to handle requests.
+     */
+    isReady(): boolean;
+    /**
+     * Returns a list of action methods available on this actor.
+     */
+    get actions(): string[];
+    /**
+     * Handles raw HTTP requests to the actor.
+     */
+    handleFetch(request: Request, opts: {}): Promise<Response>;
+    /**
+     * Handles raw WebSocket connections to the actor.
+     */
+    handleWebSocket(websocket: UniversalWebSocket, opts: {
+        request: Request;
+    }): Promise<void>;
+    get log(): Logger;
+    get rLog(): Logger;
+    /**
+     * Gets the name.
+     */
+    get name(): string;
+    /**
+     * Gets the 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<S, CP, CS, V, I, DB>>;
+    /**
+     * Gets the current state.
+     *
+     * Changing properties of this value will automatically be persisted.
+     */
+    get state(): S;
+    /**
+     * Gets the database.
+     * @experimental
+     * @throws {DatabaseNotEnabled} If the database is not enabled.
+     */
+    get db(): InferDatabaseClient<DB>;
+    /**
+     * Sets the current state.
+     *
+     * This property will automatically be persisted.
+     */
+    set state(value: S);
+    get vars(): V;
+    /**
+     * Broadcasts an event to all connected clients.
+     * @param name - The name of the event.
+     * @param args - The arguments to send with the event.
+     */
+    _broadcast<Args extends Array<unknown>>(name: string, ...args: Args): void;
+    /**
+     * Prevents the actor from sleeping until promise is complete.
+     *
+     * This allows the actor runtime to ensure that a promise completes while
+     * returning from an action request early.
+     *
+     * @param promise - The promise to run in the background.
+     */
+    _waitUntil(promise: Promise<void>): void;
+    /**
+     * Forces the state to get saved.
+     *
+     * This is helpful if running a long task that may fail later or when
+     * running a background job that updates the state.
+     *
+     * @param opts - Options for saving the state.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */
+    _sleep(): Promise<void>;
+    _stop(): Promise<void>;
+    /** Abort signal that fires when the actor is stopping. */
+    get abortSignal(): AbortSignal;
+}
+
+/**
+ * ActorContext class that provides access to actor methods and state
+ */
+declare class ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
+    #private;
+    constructor(actor: ActorInstance<TState, TConnParams, TConnState, TVars, TInput, TDatabase>);
+    /**
+     * Get the actor state
+     */
+    get state(): TState;
+    /**
+     * Get the actor variables
+     */
+    get vars(): 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<Args extends Array<unknown>>(name: string, ...args: Args): void;
+    /**
+     * Gets the logger instance.
+     */
+    get log(): Logger;
+    /**
+     * 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>>;
+    /**
+     * Returns the client for the given registry.
+     */
+    client<R extends Registry<any>>(): Client<R>;
+    /**
+     * Gets the database.
+     * @experimental
+     * @throws {DatabaseNotEnabled} If the database is not enabled.
+     */
+    get db(): 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;
+    /**
+     * AbortSignal that fires when the actor is stopping.
+     */
+    get abortSignal(): AbortSignal;
+    /**
+     * Forces the actor to sleep.
+     *
+     * Not supported on all drivers.
+     *
+     * @experimental
+     */
+    sleep(): void;
+}
+
+type InitContext = ActorContext<undefined, undefined, undefined, undefined, undefined, undefined>;
+interface ActorTypes<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
+    state?: TState;
+    connParams?: TConnParams;
+    connState?: TConnState;
+    vars?: TVars;
+    input?: TInput;
+    database?: TDatabase;
+}
+declare const ActorConfigSchema: z.ZodEffects<z.ZodEffects<z.ZodEffects<z.ZodObject<{
+    onCreate: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onStart: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onStop: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onStateChange: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onBeforeConnect: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onConnect: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onDisconnect: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onBeforeActionResponse: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onFetch: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    onWebSocket: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    actions: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>>;
+    state: z.ZodOptional<z.ZodAny>;
+    createState: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    connState: z.ZodOptional<z.ZodAny>;
+    createConnState: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    vars: z.ZodOptional<z.ZodAny>;
+    db: z.ZodOptional<z.ZodAny>;
+    createVars: z.ZodOptional<z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>>;
+    options: z.ZodDefault<z.ZodObject<{
+        createVarsTimeout: z.ZodDefault<z.ZodNumber>;
+        createConnStateTimeout: z.ZodDefault<z.ZodNumber>;
+        onConnectTimeout: z.ZodDefault<z.ZodNumber>;
+        onStopTimeout: z.ZodDefault<z.ZodNumber>;
+        stateSaveInterval: z.ZodDefault<z.ZodNumber>;
+        actionTimeout: z.ZodDefault<z.ZodNumber>;
+        waitUntilTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessTimeout: z.ZodDefault<z.ZodNumber>;
+        connectionLivenessInterval: z.ZodDefault<z.ZodNumber>;
+        noSleep: z.ZodDefault<z.ZodBoolean>;
+        sleepTimeout: z.ZodDefault<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        createVarsTimeout: number;
+        createConnStateTimeout: number;
+        onConnectTimeout: number;
+        onStopTimeout: number;
+        stateSaveInterval: number;
+        actionTimeout: number;
+        waitUntilTimeout: number;
+        connectionLivenessTimeout: number;
+        connectionLivenessInterval: number;
+        noSleep: boolean;
+        sleepTimeout: number;
+    }, {
+        createVarsTimeout?: number | undefined;
+        createConnStateTimeout?: number | undefined;
+        onConnectTimeout?: number | undefined;
+        onStopTimeout?: number | undefined;
+        stateSaveInterval?: number | undefined;
+        actionTimeout?: number | undefined;
+        waitUntilTimeout?: number | undefined;
+        connectionLivenessTimeout?: number | undefined;
+        connectionLivenessInterval?: number | undefined;
+        noSleep?: boolean | undefined;
+        sleepTimeout?: number | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    options: {
+        createVarsTimeout: number;
+        createConnStateTimeout: number;
+        onConnectTimeout: number;
+        onStopTimeout: number;
+        stateSaveInterval: number;
+        actionTimeout: number;
+        waitUntilTimeout: number;
+        connectionLivenessTimeout: number;
+        connectionLivenessInterval: number;
+        noSleep: boolean;
+        sleepTimeout: number;
+    };
+    actions: Record<string, (...args: unknown[]) => unknown>;
+    state?: any;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    state?: any;
+    options?: {
+        createVarsTimeout?: number | undefined;
+        createConnStateTimeout?: number | undefined;
+        onConnectTimeout?: number | undefined;
+        onStopTimeout?: number | undefined;
+        stateSaveInterval?: number | undefined;
+        actionTimeout?: number | undefined;
+        waitUntilTimeout?: number | undefined;
+        connectionLivenessTimeout?: number | undefined;
+        connectionLivenessInterval?: number | undefined;
+        noSleep?: boolean | undefined;
+        sleepTimeout?: number | undefined;
+    } | undefined;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    actions?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}>, {
+    options: {
+        createVarsTimeout: number;
+        createConnStateTimeout: number;
+        onConnectTimeout: number;
+        onStopTimeout: number;
+        stateSaveInterval: number;
+        actionTimeout: number;
+        waitUntilTimeout: number;
+        connectionLivenessTimeout: number;
+        connectionLivenessInterval: number;
+        noSleep: boolean;
+        sleepTimeout: number;
+    };
+    actions: Record<string, (...args: unknown[]) => unknown>;
+    state?: any;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    state?: any;
+    options?: {
+        createVarsTimeout?: number | undefined;
+        createConnStateTimeout?: number | undefined;
+        onConnectTimeout?: number | undefined;
+        onStopTimeout?: number | undefined;
+        stateSaveInterval?: number | undefined;
+        actionTimeout?: number | undefined;
+        waitUntilTimeout?: number | undefined;
+        connectionLivenessTimeout?: number | undefined;
+        connectionLivenessInterval?: number | undefined;
+        noSleep?: boolean | undefined;
+        sleepTimeout?: number | undefined;
+    } | undefined;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    actions?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}>, {
+    options: {
+        createVarsTimeout: number;
+        createConnStateTimeout: number;
+        onConnectTimeout: number;
+        onStopTimeout: number;
+        stateSaveInterval: number;
+        actionTimeout: number;
+        waitUntilTimeout: number;
+        connectionLivenessTimeout: number;
+        connectionLivenessInterval: number;
+        noSleep: boolean;
+        sleepTimeout: number;
+    };
+    actions: Record<string, (...args: unknown[]) => unknown>;
+    state?: any;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    state?: any;
+    options?: {
+        createVarsTimeout?: number | undefined;
+        createConnStateTimeout?: number | undefined;
+        onConnectTimeout?: number | undefined;
+        onStopTimeout?: number | undefined;
+        stateSaveInterval?: number | undefined;
+        actionTimeout?: number | undefined;
+        waitUntilTimeout?: number | undefined;
+        connectionLivenessTimeout?: number | undefined;
+        connectionLivenessInterval?: number | undefined;
+        noSleep?: boolean | undefined;
+        sleepTimeout?: number | undefined;
+    } | undefined;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    actions?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}>, {
+    options: {
+        createVarsTimeout: number;
+        createConnStateTimeout: number;
+        onConnectTimeout: number;
+        onStopTimeout: number;
+        stateSaveInterval: number;
+        actionTimeout: number;
+        waitUntilTimeout: number;
+        connectionLivenessTimeout: number;
+        connectionLivenessInterval: number;
+        noSleep: boolean;
+        sleepTimeout: number;
+    };
+    actions: Record<string, (...args: unknown[]) => unknown>;
+    state?: any;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}, {
+    state?: any;
+    options?: {
+        createVarsTimeout?: number | undefined;
+        createConnStateTimeout?: number | undefined;
+        onConnectTimeout?: number | undefined;
+        onStopTimeout?: number | undefined;
+        stateSaveInterval?: number | undefined;
+        actionTimeout?: number | undefined;
+        waitUntilTimeout?: number | undefined;
+        connectionLivenessTimeout?: number | undefined;
+        connectionLivenessInterval?: number | undefined;
+        noSleep?: boolean | undefined;
+        sleepTimeout?: number | undefined;
+    } | undefined;
+    db?: any;
+    onCreate?: ((...args: unknown[]) => unknown) | undefined;
+    onStart?: ((...args: unknown[]) => unknown) | undefined;
+    onStop?: ((...args: unknown[]) => unknown) | undefined;
+    onStateChange?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onConnect?: ((...args: unknown[]) => unknown) | undefined;
+    onDisconnect?: ((...args: unknown[]) => unknown) | undefined;
+    onBeforeActionResponse?: ((...args: unknown[]) => unknown) | undefined;
+    onFetch?: ((...args: unknown[]) => unknown) | undefined;
+    onWebSocket?: ((...args: unknown[]) => unknown) | undefined;
+    actions?: Record<string, (...args: unknown[]) => unknown> | undefined;
+    createState?: ((...args: unknown[]) => unknown) | undefined;
+    connState?: any;
+    createConnState?: ((...args: unknown[]) => unknown) | undefined;
+    vars?: any;
+    createVars?: ((...args: unknown[]) => unknown) | undefined;
+}>;
+interface OnConnectOptions {
+    /**
+     * The request object associated with the connection.
+     *
+     * @experimental
+     */
+    request?: Request;
+}
+type CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> = {
+    state: TState;
+} | {
+    createState: (c: InitContext, input: TInput) => TState | Promise<TState>;
+} | Record<never, never>;
+type CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> = {
+    connState: TConnState;
+} | {
+    createConnState: (c: InitContext, opts: OnConnectOptions, params: TConnParams) => TConnState | Promise<TConnState>;
+} | Record<never, never>;
+/**
+ * @experimental
+ */
+type CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase> = {
+    /**
+     * @experimental
+     */
+    vars: TVars;
+} | {
+    /**
+     * @experimental
+     */
+    createVars: (c: InitContext, driverCtx: any) => TVars | Promise<TVars>;
+} | Record<never, never>;
+interface Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
+    [Action: string]: (c: ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, ...args: any[]) => any;
+}
+/**
+ * @experimental
+ */
+type AuthIntent = "get" | "create" | "connect" | "action" | "message";
+interface BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>> {
+    /**
+     * 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, input: TInput) => 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
+     */
+    onStart?: (c: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => 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
+     */
+    onStop?: (c: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => void | Promise<void>;
+    /**
+     * 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, opts: OnConnectOptions, 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>) => 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: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, 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 request The raw HTTP request object
+     * @returns A Response object to send back, or void to continue with default routing
+     */
+    onFetch?: (c: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, request: Request, opts: {}) => 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 websocket The raw WebSocket connection
+     * @param request The original HTTP upgrade request
+     */
+    onWebSocket?: (c: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, websocket: UniversalWebSocket, opts: {
+        request: Request;
+    }) => void | Promise<void>;
+    actions: TActions;
+}
+type ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> = {
+    /**
+     * @experimental
+     */
+    db: TDatabase;
+} | Record<never, never>;
+type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> = Omit<z.infer<typeof ActorConfigSchema>, "actions" | "onCreate" | "onStart" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onFetch" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & ActorDatabaseConfig<TDatabase>;
+type ActorConfigInput<TState = undefined, TConnParams = undefined, TConnState = undefined, TVars = undefined, TInput = undefined, TDatabase extends AnyDatabaseProvider = undefined, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase> = Record<never, never>> = {
+    types?: ActorTypes<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
+} & Omit<z.input<typeof ActorConfigSchema>, "actions" | "onCreate" | "onStart" | "onStop" | "onStateChange" | "onBeforeConnect" | "onConnect" | "onDisconnect" | "onBeforeActionResponse" | "onFetch" | "onWebSocket" | "state" | "createState" | "connState" | "createConnState" | "vars" | "createVars" | "db"> & BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TActions> & CreateState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateConnState<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & CreateVars<TState, TConnParams, TConnState, TVars, TInput, TDatabase> & ActorDatabaseConfig<TDatabase>;
+declare function test<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider, TActions extends Actions<TState, TConnParams, TConnState, TVars, TInput, TDatabase>>(input: ActorConfigInput<TState, TConnParams, TConnState, TVars, TInput, TDatabase, TActions>): ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
+
+declare const ActorKeySchema: z.ZodArray<z.ZodString, "many">;
+type ActorKey = z.infer<typeof ActorKeySchema>;
+declare const CreateRequestSchema: z.ZodObject<{
+    name: z.ZodString;
+    key: z.ZodArray<z.ZodString, "many">;
+    input: z.ZodOptional<z.ZodUnknown>;
+    region: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    key: string[];
+    name: string;
+    input?: unknown;
+    region?: string | undefined;
+}, {
+    key: string[];
+    name: string;
+    input?: unknown;
+    region?: string | undefined;
+}>;
+declare const ActorQuerySchema: z.ZodUnion<[z.ZodObject<{
+    getForId: z.ZodObject<{
+        name: z.ZodString;
+        actorId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        actorId: string;
+    }, {
+        name: string;
+        actorId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    getForId: {
+        name: string;
+        actorId: string;
+    };
+}, {
+    getForId: {
+        name: string;
+        actorId: string;
+    };
+}>, z.ZodObject<{
+    getForKey: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        key: string[];
+        name: string;
+    }, {
+        key: string[];
+        name: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    getForKey: {
+        key: string[];
+        name: string;
+    };
+}, {
+    getForKey: {
+        key: string[];
+        name: string;
+    };
+}>, z.ZodObject<{
+    getOrCreateForKey: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString, "many">;
+        input: z.ZodOptional<z.ZodUnknown>;
+        region: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    }, {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    getOrCreateForKey: {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    };
+}, {
+    getOrCreateForKey: {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    };
+}>, z.ZodObject<{
+    create: z.ZodObject<{
+        name: z.ZodString;
+        key: z.ZodArray<z.ZodString, "many">;
+        input: z.ZodOptional<z.ZodUnknown>;
+        region: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    }, {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    create: {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    };
+}, {
+    create: {
+        key: string[];
+        name: string;
+        input?: unknown;
+        region?: string | undefined;
+    };
+}>]>;
+type ActorQuery = z.infer<typeof ActorQuerySchema>;
+/**
+ * Interface representing a request to create a actor.
+ */
+type CreateRequest = z.infer<typeof CreateRequestSchema>;
+
+declare class GenericConnGlobalState {
+    websockets: Map<string, WSContext<unknown>>;
+    sseStreams: Map<string, SSEStreamingApi>;
+}
+/**
+ * Exposes connection drivers for platforms that support vanilla WebSocket, SSE, and HTTP.
+ */
+declare function createGenericConnDrivers(globalState: GenericConnGlobalState): ConnectionDriversMap;
+
+/**
+ * Context for a remote procedure call.
+ *
+ * @typeParam A Actor this action belongs to
+ */
+declare class ActionContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase extends AnyDatabaseProvider> {
+    #private;
+    readonly conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>;
+    /**
+     * Should not be called directly.
+     *
+     * @param actorContext - The actor context
+     * @param conn - The connection associated with the action
+     */
+    constructor(actorContext: ActorContext<TState, TConnParams, TConnState, TVars, TInput, TDatabase>, conn: Conn<TState, TConnParams, TConnState, TVars, TInput, TDatabase>);
+    /**
+     * Get the actor state
+     */
+    get state(): TState;
+    /**
+     * Get the actor variables
+     */
+    get vars(): TVars;
+    /**
+     * Broadcasts an event to all connected clients.
+     */
+    broadcast(name: string, ...args: any[]): void;
+    /**
+     * Gets the logger instance.
+     */
+    get log(): Logger;
+    /**
+     * 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>>;
+    /**
+     * Returns the client for the given registry.
+     */
+    client<R extends Registry<any>>(): Client<R>;
+    /**
+     * @experimental
+     */
+    get db(): InferDatabaseClient<TDatabase>;
+    /**
+     * Forces the state to get saved.
+     */
+    saveState(opts: SaveStateOptions): Promise<void>;
+    /**
+     * Prevents the actor from sleeping until promise is complete.
+     */
+    waitUntil(promise: Promise<void>): void;
+    /**
+     * AbortSignal that fires when the actor is stopping.
+     */
+    get abortSignal(): AbortSignal;
+    /**
+     * Forces the actor to sleep.
+     *
+     * Not supported on all drivers.
+     *
+     * @experimental
+     */
+    sleep(): void;
+}
+
+type AnyActorDefinition = ActorDefinition<any, any, any, any, any, any, any>;
+/**
+ * Extracts the context type from an ActorDefinition
+ */
+type ActorContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB, any> ? ActorContext<S, CP, CS, V, I, DB> : never;
+/**
+ * Extracts the context type from an ActorDefinition
+ */
+type ActionContextOf<AD extends AnyActorDefinition> = AD extends ActorDefinition<infer S, infer CP, infer CS, infer V, infer I, infer DB, any> ? ActionContext<S, CP, CS, V, I, DB> : never;
+declare class ActorDefinition<S, CP, CS, V, I, DB extends AnyDatabaseProvider, R extends Actions<S, CP, CS, V, I, DB>> {
+    #private;
+    constructor(config: ActorConfig<S, CP, CS, V, I, DB>);
+    get config(): ActorConfig<S, CP, CS, V, I, DB>;
+    instantiate(): ActorInstance<S, CP, CS, V, I, DB>;
+}
+declare function lookupInRegistry(registryConfig: RegistryConfig, name: string): AnyActorDefinition;
+
+declare const TransportSchema: z.ZodEnum<["websocket", "sse"]>;
+/**
+ * Transport mechanism used to communicate between client & actor.
+ */
+type Transport = z.infer<typeof TransportSchema>;
+
+/**
+ * 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, 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);
+}
+
+/**
+ * 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;
+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);
+    /**
+     * 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.
+enc
+     * 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;
+    /**
+     * 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);
+    /**
+     * 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>;
+    /**
+     * Makes a raw HTTP request to the actor.
+     *
+     * @param input - The URL, path, or Request object
+     * @param init - Standard fetch RequestInit options
+     * @returns Promise<Response> - The raw HTTP response
+     */
+    fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+    /**
+     * Creates a raw WebSocket connection to the actor.
+     *
+     * @param path - The path for the WebSocket connection (e.g., "stream")
+     * @param protocols - Optional WebSocket subprotocols
+     * @returns WebSocket - A raw WebSocket connection
+     */
+    websocket(path?: string, protocols?: string | string[]): Promise<WebSocket>;
+    /**
+     * Resolves the actor to get its unique actor ID
+     *
+     * @returns {Promise<string>} - A promise that resolves to the actor's ID
+     */
+    resolve({ signal }?: {
+        signal?: AbortSignal;
+    }): 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>;
+
+/** 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;
+declare const TRANSPORT_SYMBOL: 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>;
+    [TRANSPORT_SYMBOL]: Transport;
+    /**
+     * Creates an instance of Client.
+     *
+     * @param {string} managerEndpoint - The manager endpoint. See {@link https://rivet.dev/docs/setup|Initial Setup} for instructions on getting the manager endpoint.
+     * @param {ClientConfig} [opts] - Options for configuring the client.
+     * @see {@link https://rivet.dev/docs/setup|Initial Setup}
+     */
+    constructor(driver: ManagerDriver, opts?: ClientConfig);
+    /**
+     * 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 function createClientWithDriver<A extends Registry<any>>(driver: ManagerDriver, config?: ClientConfig): Client<A>;
+
+type ConnectionDriversMap = Record<ConnectionDriver, ConnDriver>;
+type ActorDriverBuilder = (registryConfig: RegistryConfig, runConfig: RunConfig, managerDriver: ManagerDriver, inlineClient: AnyClient) => ActorDriver;
+interface ActorDriver {
+    loadActor(actorId: string): Promise<AnyActorInstance>;
+    getGenericConnGlobalState(actorId: string): GenericConnGlobalState;
+    getContext(actorId: string): unknown;
+    readPersistedData(actorId: string): Promise<Uint8Array | undefined>;
+    /** ActorInstance ensure that only one instance of writePersistedData is called in parallel at a time. */
+    writePersistedData(actorId: string, data: Uint8Array): Promise<void>;
+    /** ActorInstance ensure that only one instance of setAlarm is called in parallel at a time. */
+    setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void>;
+    /**
+     * @experimental
+     * This is an experimental API that may change in the future.
+     */
+    getDatabase(actorId: string): Promise<unknown | undefined>;
+    sleep?(actorId: string): Promise<void>;
+    shutdown?(immediate: boolean): Promise<void>;
+}
+declare enum ConnectionReadyState {
+    UNKNOWN = -1,
+    CONNECTING = 0,
+    OPEN = 1,
+    CLOSING = 2,
+    CLOSED = 3
+}
+interface ConnDriver<ConnDriverState = unknown> {
+    sendMessage?(actor: AnyActorInstance, conn: AnyConn, state: ConnDriverState, message: CachedSerializer<ToClient>): void;
+    /**
+     * 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, state: ConnDriverState, reason?: string): Promise<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): ConnectionReadyState | undefined;
+}
+
+/** Object representing connection that gets persisted to storage. */
+interface PersistedConn<CP, CS> {
+    connId: string;
+    token: string;
+    connDriver: ConnectionDriver;
+    connDriverState: unknown;
+    params: CP;
+    state: CS;
+    authData?: unknown;
+    subscriptions: PersistedSubscription[];
+    lastSeen: number;
+}
+interface PersistedSubscription {
+    eventName: string;
+}
+
+declare function generateConnId(): string;
+declare function generateConnToken(): string;
+type ConnId = string;
+type AnyConn = Conn<any, any, any, any, any, any>;
+declare const CONNECTION_DRIVER_WEBSOCKET = "webSocket";
+declare const CONNECTION_DRIVER_SSE = "sse";
+declare const CONNECTION_DRIVER_HTTP = "http";
+type ConnectionDriver = typeof CONNECTION_DRIVER_WEBSOCKET | typeof CONNECTION_DRIVER_SSE | typeof CONNECTION_DRIVER_HTTP;
+type ConnectionStatus = "connected" | "reconnecting";
+/**
+ * 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> {
+    #private;
+    subscriptions: Set<string>;
+    /**
+     * The proxied state that notifies of changes automatically.
+     *
+     * Any data that should be stored indefinitely should be held within this object.
+     */
+    __persist: PersistedConn<CP, CS>;
+    get params(): CP;
+    get driver(): ConnectionDriver;
+    get _stateEnabled(): boolean;
+    /**
+     * 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;
+    /**
+     * Token used to authenticate this request.
+     */
+    get _token(): string;
+    /**
+     * Status of the connection.
+     */
+    get status(): ConnectionStatus;
+    /**
+     * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
+     */
+    get lastSeen(): number;
+    /**
+     * 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>, persist: PersistedConn<CP, CS>, driver: ConnDriver, stateEnabled: boolean);
+    /**
+     * Sends a WebSocket message to the client.
+     *
+     * @param message - The message to send.
+     *
+     * @protected
+     */
+    _sendMessage(message: CachedSerializer<ToClient>): 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(eventName: string, ...args: unknown[]): void;
+    /**
+     * Disconnects the client with an optional reason.
+     *
+     * @param reason - The reason for disconnection.
+     */
+    disconnect(reason?: string): Promise<void>;
+}
+
+export { type CreateRequest as $, type ActorDriver as A, type AnyActorInstance as B, type Client as C, type DriverConfig as D, type Encoding as E, type ActorTypes as F, GenericConnGlobalState as G, ActorConfigSchema as H, type InitContext as I, type AuthIntent as J, type ActorConfig as K, test as L, type RegistryConfig as M, type RegistryActors as N, type OnConnectOptions as O, RegistryConfigSchema as P, Registry as Q, type RunConfig as R, setup as S, type ClientConfigInput as T, type UniversalWebSocket as U, type Transport as V, ActorClientError as W, ActorError as X, InternalError as Y, MalformedResponseMessage as Z, ManagerError as _, type AnyDatabaseProvider as a, type ActorActionFunction as a0, type ActorConn as a1, type EventUnsubscribe as a2, ActorConnRaw as a3, type ActorHandle as a4, ActorHandleRaw as a5, type ActorAccessor as a6, ClientRaw as a7, type CreateOptions as a8, type ExtractActorsFromRegistry as a9, type ExtractRegistryFromClient as aa, type GetOptions as ab, type GetWithIdOptions as ac, type QueryOptions as ad, type Region as ae, ActorInstance as af, type ActorOutput as ag, type CreateInput as ah, type GetForIdInput as ai, type GetOrCreateWithKeyInput as aj, type GetWithKeyInput as ak, type ManagerDisplayInformation as al, type ManagerDriver as am, DriverConfigSchema as an, RunConfigSchema as ao, type Actions as b, type ActorConfigInput as c, ActorDefinition as d, generateConnToken as e, type AnyClient as f, generateConnId as g, createClientWithDriver as h, type ActorQuery as i, type RivetCloseEvent as j, type RivetEvent as k, type RivetMessageEvent as l, type ActorKey as m, ActionContext as n, Conn as o, type ConnectionDriver as p, type ConnectionStatus as q, CONNECTION_DRIVER_HTTP as r, CONNECTION_DRIVER_SSE as s, CONNECTION_DRIVER_WEBSOCKET as t, ActorContext as u, type ActionContextOf as v, type ActorContextOf as w, type AnyActorDefinition as x, lookupInRegistry as y, createGenericConnDrivers as z };