@replit/river 0.23.15 → 0.200.0-rc.0

package/dist/services-34d97070.d.ts

@@ -0,0 +1,1366 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { Static, TSchema, TObject, TUnion, TString, TLiteral, TNever } from '@sinclair/typebox';
+import { a as TelemetryInfo, M as MessageMetadata, T as TransportClientId, b as PropagationContext, L as Logger, P as PartialTransportMessage, c as TransportMessage, O as OpaqueTransportMessage, d as LogFn, e as LoggingLevel } from './index-10ebd26a.js';
+import { C as Codec } from './types-3e5768ec.js';
+
+/**
+ * A connection is the actual raw underlying transport connection.
+ * It’s responsible for dispatching to/from the actual connection itself
+ * This should be instantiated as soon as the client/server has a connection
+ * It’s tied to the lifecycle of the underlying transport connection (i.e. if the WS drops, this connection should be deleted)
+ */
+declare abstract class Connection {
+    id: string;
+    telemetry?: TelemetryInfo;
+    constructor();
+    get loggingMetadata(): MessageMetadata;
+    /**
+     * Handle adding a callback for when a message is received.
+     * @param msg The message that was received.
+     */
+    abstract addDataListener(cb: (msg: Uint8Array) => void): void;
+    abstract removeDataListener(cb: (msg: Uint8Array) => void): void;
+    /**
+     * Handle adding a callback for when the connection is closed.
+     * This should also be called if an error happens.
+     * @param cb The callback to call when the connection is closed.
+     */
+    abstract addCloseListener(cb: () => void): void;
+    /**
+     * Handle adding a callback for when an error is received.
+     * This should only be used for this.logging errors, all cleanup
+     * should be delegated to addCloseListener.
+     *
+     * The implementer should take care such that the implemented
+     * connection will call both the close and error callbacks
+     * on an error.
+     *
+     * @param cb The callback to call when an error is received.
+     */
+    abstract addErrorListener(cb: (err: Error) => void): void;
+    /**
+     * Sends a message over the connection.
+     * @param msg The message to send.
+     * @returns true if the message was sent, false otherwise.
+     */
+    abstract send(msg: Uint8Array): boolean;
+    /**
+     * Closes the connection.
+     */
+    abstract close(): void;
+}
+interface SessionOptions {
+    /**
+     * Frequency at which to send heartbeat acknowledgements
+     */
+    heartbeatIntervalMs: number;
+    /**
+     * Number of elapsed heartbeats without a response message before we consider
+     * the connection dead.
+     */
+    heartbeatsUntilDead: number;
+    /**
+     * Duration to wait between connection disconnect and actual session disconnect
+     */
+    sessionDisconnectGraceMs: number;
+    /**
+     * The codec to use for encoding/decoding messages over the wire
+     */
+    codec: Codec;
+}
+/**
+ * A session is a higher-level abstraction that operates over the span of potentially multiple transport-level connections
+ * - It’s responsible for tracking any metadata for a particular client that might need to be persisted across connections (i.e. the sendBuffer, ack, seq)
+ * - This will only be considered disconnected if
+ *    - the server tells the client that we’ve reconnected but it doesn’t recognize us anymore (server definitely died) or
+ *    - we hit a grace period after a connection disconnect
+ */
+declare class Session<ConnType extends Connection> {
+    private codec;
+    private options;
+    readonly telemetry: TelemetryInfo;
+    /**
+     * The buffer of messages that have been sent but not yet acknowledged.
+     */
+    private sendBuffer;
+    /**
+     * The active connection associated with this session
+     */
+    connection?: ConnType;
+    /**
+     * A connection that is currently undergoing handshaking. Used to distinguish between the active
+     * connection, but still be able to close it if needed.
+     */
+    private handshakingConnection?;
+    readonly from: TransportClientId;
+    readonly to: TransportClientId;
+    /**
+     * The unique ID of this session.
+     */
+    readonly id: string;
+    /**
+     * What the other side advertised as their session ID
+     * for this session.
+     */
+    advertisedSessionId?: string;
+    /**
+     * Number of messages we've sent along this session (excluding handshake and acks)
+     */
+    private seq;
+    /**
+     * Number of unique messages we've received this session (excluding handshake and acks)
+     */
+    private ack;
+    /**
+     * The grace period between when the inner connection is disconnected
+     * and when we should consider the entire session disconnected.
+     */
+    private disconnectionGrace?;
+    /**
+     * Number of heartbeats we've sent without a response.
+     */
+    private heartbeatMisses;
+    /**
+     * The interval for sending heartbeats.
+     */
+    private heartbeat;
+    private log?;
+    constructor(conn: ConnType | undefined, from: TransportClientId, to: TransportClientId, options: SessionOptions, propagationCtx?: PropagationContext);
+    bindLogger(log: Logger): void;
+    get loggingMetadata(): MessageMetadata;
+    /**
+     * Sends a message over the session's connection.
+     * If the connection is not ready or the message fails to send, the message can be buffered for retry unless skipped.
+     *
+     * @param msg The partial message to be sent, which will be constructed into a full message.
+     * @param addToSendBuff Whether to add the message to the send buffer for retry.
+     * @returns The full transport ID of the message that was attempted to be sent.
+     */
+    send(msg: PartialTransportMessage): string;
+    sendHeartbeat(): void;
+    resetBufferedMessages(): void;
+    sendBufferedMessages(conn: ConnType): void;
+    updateBookkeeping(ack: number, seq: number): void;
+    private closeStaleConnection;
+    replaceWithNewConnection(newConn: ConnType, isTransparentReconnect: boolean): void;
+    replaceWithNewHandshakingConnection(newConn: ConnType): void;
+    beginGrace(cb: () => void): void;
+    cancelGrace(): void;
+    /**
+     * Used to close the handshaking connection, if set.
+     */
+    closeHandshakingConnection(expectedHandshakingConn?: ConnType): void;
+    close(): void;
+    get connected(): boolean;
+    get nextExpectedAck(): number;
+    get nextExpectedSeq(): number;
+    /**
+     * Check that the peer's next expected seq number matches something that is in our send buffer
+     * _or_ matches our actual next seq.
+     */
+    nextExpectedSeqInRange(nextExpectedSeq: number): boolean;
+    advanceAckForTesting(by: number): void;
+    constructMsg<Payload>(partialMsg: PartialTransportMessage<Payload>): TransportMessage<Payload>;
+    inspectSendBuffer(): ReadonlyArray<OpaqueTransportMessage>;
+}
+
+type ConnectionStatus = 'connect' | 'disconnect';
+declare const ProtocolError: {
+    readonly RetriesExceeded: "conn_retry_exceeded";
+    readonly HandshakeFailed: "handshake_failed";
+    readonly MessageOrderingViolated: "message_ordering_violated";
+};
+type ProtocolErrorType = (typeof ProtocolError)[keyof typeof ProtocolError];
+interface EventMap {
+    message: OpaqueTransportMessage;
+    connectionStatus: {
+        status: ConnectionStatus;
+        conn: Connection;
+    };
+    sessionStatus: {
+        status: ConnectionStatus;
+        session: Session<Connection>;
+    };
+    protocolError: {
+        type: ProtocolErrorType;
+        message: string;
+    };
+    transportStatus: {
+        status: TransportStatus;
+    };
+}
+type EventTypes = keyof EventMap;
+type EventHandler<K extends EventTypes> = (event: EventMap[K]) => unknown;
+declare class EventDispatcher<T extends EventTypes> {
+    private eventListeners;
+    removeAllListeners(): void;
+    numberOfListeners<K extends T>(eventType: K): number;
+    addEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    removeEventListener<K extends T>(eventType: K, handler: EventHandler<K>): void;
+    dispatchEvent<K extends T>(eventType: K, event: EventMap[K]): void;
+}
+
+/**
+ * Options to control the backoff and retry behavior of the client transport's connection behaviour.
+ *
+ * River implements exponential backoff with jitter to prevent flooding the server
+ * when there's an issue with connection establishment.
+ *
+ * The backoff is calculated via the following:
+ *   backOff = min(jitter + {@link baseIntervalMs} * 2 ^ budget_consumed, {@link maxBackoffMs})
+ *
+ * We use a leaky bucket rate limit with a budget of {@link attemptBudgetCapacity} reconnection attempts.
+ * Budget only starts to restore after a successful handshake at a rate of one budget per {@link budgetRestoreIntervalMs}.
+ */
+interface ConnectionRetryOptions {
+    /**
+     * The base interval to wait before retrying a connection.
+     */
+    baseIntervalMs: number;
+    /**
+     * The maximum random jitter to add to the total backoff time.
+     */
+    maxJitterMs: number;
+    /**
+     * The maximum amount of time to wait before retrying a connection.
+     * This does not include the jitter.
+     */
+    maxBackoffMs: number;
+    /**
+     * The max number of times to attempt a connection before a successful handshake.
+     * This persists across connections but starts restoring budget after a successful handshake.
+     * The restoration interval depends on {@link budgetRestoreIntervalMs}
+     */
+    attemptBudgetCapacity: number;
+    /**
+     * After a successful connection attempt, how long to wait before we restore a single budget.
+     */
+    budgetRestoreIntervalMs: number;
+}
+declare class LeakyBucketRateLimit {
+    private budgetConsumed;
+    private intervalHandles;
+    private readonly options;
+    constructor(options: ConnectionRetryOptions);
+    getBackoffMs(user: TransportClientId): number;
+    get totalBudgetRestoreTime(): number;
+    consumeBudget(user: TransportClientId): void;
+    getBudgetConsumed(user: TransportClientId): number;
+    hasBudget(user: TransportClientId): boolean;
+    startRestoringBudget(user: TransportClientId): void;
+    private stopLeak;
+    close(): void;
+}
+
+type TransportOptions = SessionOptions;
+type ProvidedTransportOptions = Partial<TransportOptions>;
+type ClientTransportOptions = TransportOptions & ConnectionRetryOptions;
+type ProvidedClientTransportOptions = Partial<ClientTransportOptions>;
+type ServerTransportOptions = TransportOptions;
+type ProvidedServerTransportOptions = Partial<ServerTransportOptions>;
+
+/**
+ * Represents the possible states of a transport.
+ * @property {'open'} open - The transport is open and operational (note that this doesn't mean it is actively connected)
+ * @property {'closed'} closed - The transport is permanently closed and cannot be reopened.
+ */
+type TransportStatus = 'open' | 'closed';
+/**
+ * Transports manage the lifecycle (creation/deletion) of sessions and connections. Its responsibilities include:
+ *
+ *  1) Constructing a new {@link Session} and {@link Connection} on {@link TransportMessage}s from new clients.
+ *     After constructing the {@link Connection}, {@link onConnect} is called which adds it to the connection map.
+ *  2) Delegating message listening of the connection to the newly created {@link Connection}.
+ *     From this point on, the {@link Connection} is responsible for *reading* and *writing*
+ *     messages from the connection.
+ *  3) When a connection is closed, the {@link Transport} calls {@link onDisconnect} which closes the
+ *     connection via {@link Connection.close} and removes it from the {@link connections} map.
+
+ *
+ * ```plaintext
+ *            ▲
+ *  incoming  │
+ *  messages  │
+ *            ▼
+ *      ┌─────────────┐   1:N   ┌───────────┐   1:1*  ┌────────────┐
+ *      │  Transport  │ ◄─────► │  Session  │ ◄─────► │ Connection │
+ *      └─────────────┘         └───────────┘         └────────────┘
+ *            ▲                               * (may or may not be initialized yet)
+ *            │
+ *            ▼
+ *      ┌───────────┐
+ *      │ Message   │
+ *      │ Listeners │
+ *      └───────────┘
+ * ```
+ * @abstract
+ */
+declare abstract class Transport<ConnType extends Connection> {
+    /**
+     * The status of the transport.
+     */
+    private status;
+    /**
+     * The {@link Codec} used to encode and decode messages.
+     */
+    codec: Codec;
+    /**
+     * The client ID of this transport.
+     */
+    clientId: TransportClientId;
+    /**
+     * The map of {@link Session}s managed by this transport.
+     */
+    sessions: Map<TransportClientId, Session<ConnType>>;
+    /**
+     * The map of {@link Connection}s managed by this transport.
+     */
+    get connections(): Map<string, ConnType>;
+    /**
+     * The event dispatcher for handling events of type EventTypes.
+     */
+    eventDispatcher: EventDispatcher<EventTypes>;
+    /**
+     * The options for this transport.
+     */
+    protected options: TransportOptions;
+    log?: Logger;
+    /**
+     * Creates a new Transport instance.
+     * This should also set up {@link onConnect}, and {@link onDisconnect} listeners.
+     * @param codec The codec used to encode and decode messages.
+     * @param clientId The client ID of this transport.
+     */
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedTransportOptions);
+    bindLogger(fn: LogFn | Logger, level?: LoggingLevel): void;
+    /**
+     * This is called immediately after a new connection is established and we
+     * may or may not know the identity of the connected client.
+     * It should attach all the necessary listeners to the connection for lifecycle
+     * events (i.e. data, close, error)
+     *
+     * This method is implemented by {@link ClientTransport} and {@link ServerTransport}.
+     */
+    protected abstract handleConnection(conn: ConnType, to: TransportClientId): void;
+    /**
+     * Called when a new connection is established
+     * and we know the identity of the connected client.
+     * @param conn The connection object.
+     */
+    protected onConnect(conn: ConnType, session: Session<ConnType>, isTransparentReconnect: boolean): void;
+    protected createSession(to: TransportClientId, conn?: ConnType, propagationCtx?: PropagationContext): Session<ConnType>;
+    protected createNewSession({ to, conn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn: ConnType;
+        sessionId: string;
+        propagationCtx?: PropagationContext;
+    }): Session<ConnType>;
+    protected getExistingSession({ to, sessionId, nextExpectedSeq, }: {
+        to: TransportClientId;
+        sessionId: string;
+        nextExpectedSeq: number;
+    }): false | Session<ConnType>;
+    protected getOrCreateSession({ to, conn, handshakingConn, sessionId, propagationCtx, }: {
+        to: TransportClientId;
+        conn?: ConnType;
+        handshakingConn?: ConnType;
+        sessionId?: string;
+        propagationCtx?: PropagationContext;
+    }): {
+        session: Session<ConnType>;
+        isReconnect: boolean;
+        isTransparentReconnect: boolean;
+    };
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
+    /**
+     * The downstream implementation needs to call this when a connection is closed.
+     * @param conn The connection object.
+     * @param connectedTo The peer we are connected to.
+     */
+    protected onDisconnect(conn: ConnType, session: Session<ConnType>): void;
+    /**
+     * Parses a message from a Uint8Array into a {@link OpaqueTransportMessage}.
+     * @param msg The message to parse.
+     * @returns The parsed message, or null if the message is malformed or invalid.
+     */
+    protected parseMsg(msg: Uint8Array, conn: ConnType): OpaqueTransportMessage | null;
+    /**
+     * Called when a message is received by this transport.
+     * You generally shouldn't need to override this in downstream transport implementations.
+     * @param msg The received message.
+     */
+    protected handleMsg(msg: OpaqueTransportMessage, conn: ConnType): void;
+    /**
+     * Adds a listener to this transport.
+     * @param the type of event to listen for
+     * @param handler The message handler to add.
+     */
+    addEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
+    /**
+     * Removes a listener from this transport.
+     * @param the type of event to un-listen on
+     * @param handler The message handler to remove.
+     */
+    removeEventListener<K extends EventTypes, T extends EventHandler<K>>(type: K, handler: T): void;
+    /**
+     * Sends a message over this transport, delegating to the appropriate connection to actually
+     * send the message.
+     * @param msg The message to send.
+     * @returns The ID of the sent message or undefined if it wasn't sent
+     */
+    send(to: TransportClientId, msg: PartialTransportMessage): string;
+    sendCloseControl(to: TransportClientId, streamId: string): string;
+    sendRequestCloseControl(to: TransportClientId, streamId: string): string;
+    sendAbort(to: TransportClientId, streamId: string, payload: ErrResult<Static<typeof OutputReaderErrorSchema | typeof InputReaderErrorSchema>>): string;
+    protected protocolError(type: ProtocolErrorType, message: string): void;
+    /**
+     * Default close implementation for transports. You should override this in the downstream
+     * implementation if you need to do any additional cleanup and call super.close() at the end.
+     * Closes the transport. Any messages sent while the transport is closed will be silently discarded.
+     */
+    close(): void;
+    getStatus(): TransportStatus;
+}
+
+type ConstructHandshake<T extends TSchema> = () => Static<T> | Promise<Static<T>>;
+type ValidateHandshake<T extends TSchema> = (metadata: Static<T>, previousParsedMetadata?: ParsedMetadata) => false | ParsedMetadata | Promise<false | ParsedMetadata>;
+interface ClientHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the client sends to the server
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Gets the {@link HandshakeRequestMetadata} to send to the server.
+     */
+    construct: ConstructHandshake<MetadataSchema>;
+}
+interface ServerHandshakeOptions<MetadataSchema extends TSchema = TSchema> {
+    /**
+     * Schema for the metadata that the server receives from the client
+     * during the handshake.
+     */
+    schema: MetadataSchema;
+    /**
+     * Parses the {@link HandshakeRequestMetadata} sent by the client, transforming
+     * it into {@link ParsedHandshakeMetadata}.
+     *
+     * May return `false` if the client should be rejected.
+     *
+     * @param metadata - The metadata sent by the client.
+     * @param session - The session that the client would be associated with.
+     * @param isReconnect - Whether the client is reconnecting to the session,
+     *                      or if this is a new session.
+     */
+    validate: ValidateHandshake<MetadataSchema>;
+}
+declare function createClientHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, construct: ConstructHandshake<MetadataSchema>): ClientHandshakeOptions;
+declare function createServerHandshakeOptions<MetadataSchema extends TSchema = TSchema>(schema: MetadataSchema, validate: ValidateHandshake<MetadataSchema>): ServerHandshakeOptions;
+
+declare abstract class ClientTransport<ConnType extends Connection> extends Transport<ConnType> {
+    /**
+     * The options for this transport.
+     */
+    protected options: ClientTransportOptions;
+    /**
+     * The map of reconnect promises for each client ID.
+     */
+    inflightConnectionPromises: Map<TransportClientId, Promise<ConnType>>;
+    retryBudget: LeakyBucketRateLimit;
+    /**
+     * A flag indicating whether the transport should automatically reconnect
+     * when a connection is dropped.
+     * Realistically, this should always be true for clients unless you are writing
+     * tests or a special case where you don't want to reconnect.
+     */
+    reconnectOnConnectionDrop: boolean;
+    /**
+     * Optional handshake options for this client.
+     */
+    handshakeExtensions?: ClientHandshakeOptions;
+    constructor(clientId: TransportClientId, providedOptions?: ProvidedClientTransportOptions);
+    extendHandshake(options: ClientHandshakeOptions): void;
+    protected handleConnection(conn: ConnType, to: TransportClientId): void;
+    receiveHandshakeResponseMessage(data: Uint8Array, conn: ConnType): Session<ConnType> | false;
+    /**
+     * Abstract method that creates a new {@link Connection} object.
+     * This should call {@link handleConnection} when the connection is created.
+     * The downstream client implementation needs to implement this.
+     *
+     * @param to The client ID of the node to connect to.
+     * @returns The new connection object.
+     */
+    protected abstract createNewOutgoingConnection(to: TransportClientId): Promise<ConnType>;
+    /**
+     * Manually attempts to connect to a client.
+     * @param to The client ID of the node to connect to.
+     */
+    connect(to: TransportClientId): Promise<void>;
+    protected deleteSession({ session, closeHandshakingConnection, handshakingConn, }: {
+        session: Session<ConnType>;
+        closeHandshakingConnection: boolean;
+        handshakingConn?: ConnType;
+    }): void;
+    protected sendHandshake(to: TransportClientId, conn: ConnType): Promise<boolean>;
+    close(): void;
+}
+
+/**
+ * ServiceContext exist for the purpose of declaration merging
+ * to extend the context with additional properties.
+ *
+ * For example:
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ *
+ * createServer(someTransport, myServices, { extendedContext: { db: myDb } });
+ * ```
+ *
+ * Once you do this, your {@link ProcedureHandlerContext} will have `db` property on it.
+ */
+interface ServiceContext {
+}
+/**
+ * The parsed metadata schema for a service. This is the
+ * return value of the {@link ServerHandshakeOptions.validate}
+ * if the handshake extension is used.
+ *
+ * You should use declaration merging to extend this interface
+ * with the sanitized metadata.
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ParsedMetadata {
+ *     userId: number;
+ *   }
+ * }
+ * ```
+ */
+interface ParsedMetadata {
+}
+/**
+ * This is passed to every procedure handler and contains various context-level
+ * information and utilities. This may be extended, see {@link ServiceContext}
+ */
+type ProcedureHandlerContext<State> = ServiceContext & {
+    /**
+     * State for this service as defined by the service definition.
+     */
+    state: State;
+    /**
+     * Metadata parsed on the server. See {@link ParsedMetadata}
+     */
+    metadata: ParsedMetadata;
+    /**
+     * The ID of the client that sent this request.
+     */
+    from: TransportClientId;
+    /**
+     * An AbortController for this stream. This is used to abort the stream from the
+     * handler and notify the client that the stream was aborted.
+     *
+     * Important to note that this controller is owned by the handler, if you
+     * want to listen to aborts coming from the client, you should use the
+     * {@link clientAbortSignal}.
+     *
+     * Aborts are not the same as closing streams gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    abortController: AbortController;
+    /**
+     * You can listen to clientAbortSignal this to check if the client aborted the request,
+     * or if the request was aborted due to an unexpected disconnect from the calling
+     * session.
+     *
+     * If the procedure has a read stream (e.g. upload or stream), the procedure will
+     * notified of aborts as part of the stream, but you may still want to use
+     * this signal as it is triggered immediately after an abort comes in,
+     * in readStreams some data may be buffered before the abort result shows up.
+     *
+     * Important to note that this signal is owned by the client, you have a separate
+     * signal inside {@link abortController} for aborts triggered within the handler.
+     *
+     * Aborts are not the same as closing streams gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    clientAbortSignal: AbortSignal;
+    /**
+     * Lets you add a function that will run when the request is done, this can be
+     * due to an abort (from either side), error, or success. If the callback is
+     * added after the stream ended, it will run immediately.
+     */
+    onRequestFinished: (callback: () => void) => void;
+};
+
+declare const StreamDrainedError: {
+    readonly code: "STREAM_DRAINED";
+    readonly message: "Stream was drained";
+};
+type ReadStreamResult<T, E extends Static<BaseErrorSchemaType>> = Result<T, E | typeof StreamDrainedError>;
+/**
+ * A `ReadStream` represents a stream of data.
+ *
+ * This stream is not closable by the reader, the reader must wait for
+ * the writer to close it.
+ *
+ * The stream can only be locked (aka consumed) once and will remain
+ * locked, trying to lock the stream again will throw an TypeError.
+ */
+interface ReadStream<T, E extends Static<BaseErrorSchemaType>> {
+    /**
+     * Stream implements AsyncIterator API and can be consumed via
+     * for-await-of loops.
+     *
+     */
+    [Symbol.asyncIterator](): {
+        next(): Promise<{
+            done: false;
+            value: ReadStreamResult<T, E>;
+        } | {
+            done: true;
+            value: undefined;
+        }>;
+    };
+    /**
+     * `asArray` locks the stream and returns a promise that resolves
+     * with an array of the stream's content when the stream is closed.
+     *
+     */
+    asArray(): Promise<Array<ReadStreamResult<T, E>>>;
+    /**
+     * `drain` locks the stream and discards any existing or future data.
+     *
+     * If there is an existing Promise waiting for the next value,
+     * `drain` causes it to resolve with a {@link StreamDrainedError} error.
+     */
+    drain(): undefined;
+    /**
+     * `isLocked` returns true if the stream is locked.
+     */
+    isLocked(): boolean;
+    /**
+     * `onClose` registers a callback that will be called when the stream
+     * is closed. Returns a function that can be used to unregister the
+     * listener.
+     */
+    onClose(cb: () => void): () => void;
+    /**
+     * `isClosed` returns true if the stream was closed by the writer.
+     *
+     * Note that the stream can still have queued data and can still be
+     * consumed.
+     */
+    isClosed(): boolean;
+    /**
+     * `requestClose` sends a request to the writer to close the stream,
+     * and resolves the writer closes its end of the stream..
+     *
+     * The stream can still receive more data after the request is sent. If you
+     * no longer wish to use the stream, make sure to call `drain`.
+     */
+    requestClose(): Promise<undefined>;
+    /**
+     * `isCloseRequested` checks if the reader has requested to close the stream.
+     */
+    isCloseRequested(): boolean;
+}
+/**
+ * A `WriteStream` is a streams that can be written to.
+ */
+interface WriteStream<T> {
+    /**
+     * `write` writes a value to the stream. An error is thrown if writing to a closed stream.
+     */
+    write(value: T): undefined;
+    /**
+     * `close` signals the closure of the write stream, informing the reader that the stream is complete.
+     * Calling close multiple times has no effect.
+     */
+    close(): undefined;
+    /**
+     * `isCloseRequested` checks if the reader has requested to close the stream.
+     */
+    isCloseRequested(): boolean;
+    /**
+     * `onCloseRequest` registers a callback that will be called when the stream's
+     * reader requests a close. Returns a function that can be used to unregister the
+     * listener.
+     */
+    onCloseRequest(cb: () => void): () => void;
+    /**
+     * `isClosed` returns true if the stream was closed by the writer.
+     */
+    isClosed(): boolean;
+}
+
+interface CallOptions {
+    signal?: AbortSignal;
+}
+type RpcFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (init: ProcInit<Router, ProcName>, options?: CallOptions) => Promise<Result<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>>;
+type UploadFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (init: ProcInit<Router, ProcName>, options?: CallOptions) => [
+    WriteStream<ProcInput<Router, ProcName>>,
+    () => Promise<Result<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>>
+];
+type StreamFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (init: ProcInit<Router, ProcName>, options?: CallOptions) => [
+    WriteStream<ProcInput<Router, ProcName>>,
+    ReadStream<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>
+];
+type SubscriptionFn<Router extends AnyService, ProcName extends keyof Router['procedures']> = (init: ProcInit<Router, ProcName>, options?: CallOptions) => ReadStream<ProcOutput<Router, ProcName>, ProcErrors<Router, ProcName>>;
+/**
+ * A helper type to transform an actual service type into a type
+ * we can case to in the proxy.
+ * @template Router - The type of the Router.
+ */
+type ServiceClient<Router extends AnyService> = {
+    [ProcName in keyof Router['procedures']]: ProcType<Router, ProcName> extends 'rpc' ? {
+        rpc: RpcFn<Router, ProcName>;
+    } : ProcType<Router, ProcName> extends 'upload' ? {
+        upload: UploadFn<Router, ProcName>;
+    } : ProcType<Router, ProcName> extends 'stream' ? {
+        stream: StreamFn<Router, ProcName>;
+    } : ProcType<Router, ProcName> extends 'subscription' ? {
+        subscribe: SubscriptionFn<Router, ProcName>;
+    } : never;
+};
+/**
+ * Defines a type that represents a client for a server with a set of services.
+ * @template Srv - The type of the server.
+ */
+type Client<Services extends AnyServiceSchemaMap, IS extends InstantiatedServiceSchemaMap<Services> = InstantiatedServiceSchemaMap<Services>> = {
+    [SvcName in keyof IS]: ServiceClient<IS[SvcName]>;
+};
+interface ClientOptions {
+    connectOnInvoke: boolean;
+    eagerlyConnect: boolean;
+}
+/**
+ * Creates a client for a given server using the provided transport.
+ * Note that the client only needs the type of the server, not the actual
+ * server definition itself.
+ *
+ * This relies on a proxy to dynamically create the client, so the client
+ * will be typed as if it were the actual server with the appropriate services
+ * and procedures.
+ *
+ * @template Srv - The type of the server.
+ * @param {Transport} transport - The transport to use for communication.
+ * @param {TransportClientId} serverId - The ID of the server to connect to.
+ * @param {Partial<ClientOptions>} providedClientOptions - The options for the client.
+ * @returns The client for the server.
+ */
+declare function createClient<ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions & {
+    handshakeOptions: ClientHandshakeOptions;
+}>): Client<ServiceSchemaMap>;
+
+type TLiteralString = TLiteral<string>;
+type BaseErrorSchemaType = TObject<{
+    code: TLiteralString | TUnion<Array<TLiteralString>>;
+    message: TLiteralString | TString;
+}> | TObject<{
+    code: TLiteralString | TUnion<Array<TLiteralString>>;
+    message: TLiteralString | TString;
+    extras: TSchema;
+}>;
+interface OkResult<T> {
+    ok: true;
+    payload: T;
+}
+interface ErrResult<Err extends Static<BaseErrorSchemaType>> {
+    ok: false;
+    payload: Err;
+}
+type Result<T, Err extends Static<BaseErrorSchemaType>> = OkResult<T> | ErrResult<Err>;
+declare function Ok<const T extends Array<unknown>>(p: T): OkResult<T>;
+declare function Ok<const T extends ReadonlyArray<unknown>>(p: T): OkResult<T>;
+declare function Ok<const T>(payload: T): OkResult<T>;
+declare function Err<const Err extends Static<BaseErrorSchemaType>>(error: Err): ErrResult<Err>;
+/**
+ * Refine a {@link Result} type to its returned payload.
+ */
+type ResultUnwrapOk<R> = R extends Result<infer T, infer __E> ? T : never;
+/**
+ * Refine a {@link Result} type to its error payload.
+ */
+type ResultUnwrapErr<R> = R extends Result<infer __T, infer Err> ? Err : never;
+/**
+ * Retrieve the output type for a procedure, represented as a {@link Result}
+ * type.
+ * Example:
+ * ```
+ * type Message = Output<typeof client, 'serviceName', 'procedureName'>
+ * ```
+ */
+type Output<RiverClient, ServiceName extends keyof RiverClient, ProcedureName extends keyof RiverClient[ServiceName], Procedure = RiverClient[ServiceName][ProcedureName], Fn extends (...args: never) => unknown = (...args: never) => unknown> = RiverClient extends Client<infer __ServiceSchemaMap> ? Procedure extends object ? Procedure extends object & {
+    rpc: infer RpcHandler extends Fn;
+} ? Awaited<ReturnType<RpcHandler>> : Procedure extends object & {
+    upload: infer UploadHandler extends Fn;
+} ? ReturnType<UploadHandler> extends [
+    infer __UploadInputMessage,
+    (...args: never) => Promise<infer UploadOutputMessage>
+] ? UploadOutputMessage : never : Procedure extends object & {
+    stream: infer StreamHandler extends Fn;
+} ? ReturnType<StreamHandler> extends [
+    infer __StreamInputMessage,
+    ReadStream<infer StreamOutputMessage, Static<BaseErrorSchemaType>>
+] ? StreamOutputMessage : never : Procedure extends object & {
+    subscribe: infer SubscriptionHandler extends Fn;
+} ? Awaited<ReturnType<SubscriptionHandler>> extends ReadStream<infer SubscriptionOutputMessage, Static<BaseErrorSchemaType>> ? SubscriptionOutputMessage : never : never : never : never;
+
+/**
+ * Brands a type to prevent it from being directly constructed.
+ */
+type Branded<T> = T & {
+    readonly __BRAND_DO_NOT_USE: unique symbol;
+};
+/**
+ * Unbrands a {@link Branded} type.
+ */
+type Unbranded<T> = T extends Branded<infer U> ? U : never;
+/**
+ * The valid {@link Procedure} types. The `stream` and `upload` types can optionally have a
+ * different type for the very first initialization message. The suffixless types correspond to
+ * gRPC's four combinations of stream / non-stream in each direction.
+ */
+type ValidProcType = 'rpc' | 'upload' | 'subscription' | 'stream';
+/**
+ * Represents the payload type for {@link Procedure}s.
+ */
+type PayloadType = TSchema;
+/**
+ * UNCAUGHT_ERROR_CODE is the code that is used when an error is thrown
+ * inside a procedure handler that's not required.
+ */
+declare const UNCAUGHT_ERROR_CODE: "UNCAUGHT_ERROR";
+/**
+ * UNEXPECTED_DISCONNECT_CODE is the code used the stream's session
+ * disconnect unexpetedly.
+ */
+declare const UNEXPECTED_DISCONNECT_CODE: "UNEXPECTED_DISCONNECT";
+/**
+ * INVALID_REQUEST_CODE is the code used when a client's request is invalid.
+ */
+declare const INVALID_REQUEST_CODE: "INVALID_REQUEST";
+/**
+ * OutputReaderErrorSchema is the schema for all the errors that can be
+ * emitted in the Output ReadStream on the client.
+ */
+declare const OutputReaderErrorSchema: _sinclair_typebox.TObject<{
+    code: TUnion<[_sinclair_typebox.TLiteral<"INTERNAL_RIVER_ERROR">, _sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">, _sinclair_typebox.TLiteral<"INVALID_REQUEST">, _sinclair_typebox.TLiteral<"ABORT">]>;
+    message: _sinclair_typebox.TString;
+}>;
+/**
+ * InputReaderErrorSchema is the schema for all the errors that can be
+ * emitted in the Input ReadStream on the server.
+ */
+declare const InputReaderErrorSchema: _sinclair_typebox.TObject<{
+    code: TUnion<[_sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">, _sinclair_typebox.TLiteral<"INVALID_REQUEST">, _sinclair_typebox.TLiteral<"ABORT">]>;
+    message: _sinclair_typebox.TString;
+}>;
+/**
+ * Represents an acceptable schema to pass to a procedure.
+ * Just a type of a schema, not an actual schema.
+ */
+type ProcedureErrorSchemaType = TUnion<Array<BaseErrorSchemaType>> | BaseErrorSchemaType | TNever;
+/**
+ * Procedure for a single message in both directions (1:1).
+ *
+ * @template State - The context state object.
+ * @template Init - The TypeBox schema of the initialization object.
+ * @template Output - The TypeBox schema of the output object.
+ * @template Err - The TypeBox schema of the error object.
+ */
+interface RpcProcedure<State, Init extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType> {
+    type: 'rpc';
+    init: Init;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler(context: ProcedureHandlerContext<State>, init: Static<Init>): Promise<Result<Static<Output>, Static<Err>>>;
+}
+/**
+ * Procedure for a client-stream (potentially preceded by an initialization message),
+ * single message from server (n:1).
+ *
+ * @template State - The context state object.
+ * @template Init - The TypeBox schema of the initialization object.
+ * @template Input - The TypeBox schema of the input object.
+ * @template Output - The TypeBox schema of the output object.
+ * @template Err - The TypeBox schema of the error object.
+ */
+interface UploadProcedure<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType> {
+    type: 'upload';
+    init: Init;
+    input: Input;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler(context: ProcedureHandlerContext<State>, init: Static<Init>, input: ReadStream<Static<Input>, Static<typeof InputReaderErrorSchema>>): Promise<Result<Static<Output>, Static<Err>>>;
+}
+/**
+ * Procedure for a single message from client, stream from server (1:n).
+ *
+ * @template State - The context state object.
+ * @template Init - The TypeBox schema of the initialization object.
+ * @template Output - The TypeBox schema of the output object.
+ * @template Err - The TypeBox schema of the error object.
+ */
+interface SubscriptionProcedure<State, Init extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType> {
+    type: 'subscription';
+    init: Init;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler(context: ProcedureHandlerContext<State>, init: Static<Init>, output: WriteStream<Result<Static<Output>, Static<Err>>>): Promise<void | undefined>;
+}
+/**
+ * Procedure for a bidirectional stream (potentially preceded by an initialization message),
+ * (n:n).
+ *
+ * @template State - The context state object.
+ * @template Init - The TypeBox schema of the initialization object.
+ * @template Input - The TypeBox schema of the input object.
+ * @template Output - The TypeBox schema of the output object.
+ * @template Err - The TypeBox schema of the error object.
+ */
+interface StreamProcedure<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType> {
+    type: 'stream';
+    init: Init;
+    input: Input;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler(context: ProcedureHandlerContext<State>, init: Static<Init>, input: ReadStream<Static<Input>, Static<typeof InputReaderErrorSchema>>, output: WriteStream<Result<Static<Output>, Static<Err>>>): Promise<void | undefined>;
+}
+/**
+ * Represents any {@link Procedure} type.
+ *
+ * @template State - The context state object. You can provide this to constrain
+ *                   the type of procedures.
+ */
+type AnyProcedure<State = object> = Procedure<State, ValidProcType, PayloadType, PayloadType | null, PayloadType, ProcedureErrorSchemaType>;
+/**
+ * Represents a map of {@link Procedure}s.
+ *
+ * @template State - The context state object. You can provide this to constrain
+ *                   the type of procedures.
+ */
+type ProcedureMap<State = object> = Record<string, AnyProcedure<State>>;
+/**
+ * Creates an {@link RpcProcedure}.
+ */
+declare function rpc<State, Init extends PayloadType, Output extends PayloadType>(def: {
+    init: Init;
+    output: Output;
+    errors?: never;
+    description?: string;
+    handler: RpcProcedure<State, Init, Output, TNever>['handler'];
+}): Branded<RpcProcedure<State, Init, Output, TNever>>;
+declare function rpc<State, Init extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType>(def: {
+    init: Init;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler: RpcProcedure<State, Init, Output, Err>['handler'];
+}): Branded<RpcProcedure<State, Init, Output, Err>>;
+/**
+ * Creates an {@link UploadProcedure}, optionally with an initialization message.
+ */
+declare function upload<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType>(def: {
+    init: Init;
+    input: Input;
+    output: Output;
+    errors?: never;
+    description?: string;
+    handler: UploadProcedure<State, Init, Input, Output, TNever>['handler'];
+}): Branded<UploadProcedure<State, Init, Input, Output, TNever>>;
+declare function upload<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType>(def: {
+    init: Init;
+    input: Input;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler: UploadProcedure<State, Init, Input, Output, Err>['handler'];
+}): Branded<UploadProcedure<State, Init, Input, Output, Err>>;
+/**
+ * Creates a {@link SubscriptionProcedure}.
+ */
+declare function subscription<State, Init extends PayloadType, Output extends PayloadType>(def: {
+    init: Init;
+    output: Output;
+    errors?: never;
+    description?: string;
+    handler: SubscriptionProcedure<State, Init, Output, TNever>['handler'];
+}): Branded<SubscriptionProcedure<State, Init, Output, TNever>>;
+declare function subscription<State, Init extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType>(def: {
+    init: Init;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler: SubscriptionProcedure<State, Init, Output, Err>['handler'];
+}): Branded<SubscriptionProcedure<State, Init, Output, Err>>;
+/**
+ * Creates a {@link StreamProcedure}, optionally with an initialization message.
+ */
+declare function stream<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType>(def: {
+    init: Init;
+    input: Input;
+    output: Output;
+    errors?: never;
+    description?: string;
+    handler: StreamProcedure<State, Init, Input, Output, TNever>['handler'];
+}): Branded<StreamProcedure<State, Init, Input, Output, TNever>>;
+declare function stream<State, Init extends PayloadType, Input extends PayloadType, Output extends PayloadType, Err extends ProcedureErrorSchemaType>(def: {
+    init: Init;
+    input: Input;
+    output: Output;
+    errors: Err;
+    description?: string;
+    handler: StreamProcedure<State, Init, Input, Output, Err>['handler'];
+}): Branded<StreamProcedure<State, Init, Input, Output, Err>>;
+/**
+ * Defines a Procedure type that can be a:
+ * - {@link RpcProcedure} for a single message in both directions (1:1)
+ * - {@link UploadProcedure} for a client-stream (potentially preceded by an
+ *   initialization message)
+ * - {@link SubscriptionProcedure} for a single message from client, stream from server (1:n)
+ * - {@link StreamProcedure} for a bidirectional stream (potentially preceded by an
+ *    initialization message)
+ *
+ * @template State - The TypeBox schema of the state object.
+ * @template Ty - The type of the procedure.
+ * @template Input - The TypeBox schema of the input object.
+ * @template Init - The TypeBox schema of the input initialization object, if any.
+ * @template Output - The TypeBox schema of the output object.
+ */
+type Procedure<State, Ty extends ValidProcType, Init extends PayloadType, Input extends PayloadType | null, Output extends PayloadType, Err extends ProcedureErrorSchemaType> = {
+    type: Ty;
+} & (Input extends PayloadType ? Ty extends 'upload' ? UploadProcedure<State, Init, Input, Output, Err> : Ty extends 'stream' ? StreamProcedure<State, Init, Input, Output, Err> : never : Ty extends 'rpc' ? RpcProcedure<State, Init, Output, Err> : Ty extends 'subscription' ? SubscriptionProcedure<State, Init, Output, Err> : never);
+/**
+ * Holds the {@link Procedure} creation functions. Use these to create
+ * procedures for services. You aren't allowed to create procedures directly.
+ */
+declare const Procedure: {
+    rpc: typeof rpc;
+    upload: typeof upload;
+    subscription: typeof subscription;
+    stream: typeof stream;
+};
+
+/**
+ * An instantiated service, probably from a {@link ServiceSchema}.
+ *
+ * You shouldn't construct these directly, use {@link ServiceSchema} instead.
+ */
+interface Service<State extends object, Procs extends ProcedureMap<State>> {
+    readonly state: State;
+    readonly procedures: Procs;
+}
+/**
+ * Represents any {@link Service} object.
+ */
+type AnyService = Service<object, ProcedureMap>;
+/**
+ * Represents any {@link ServiceSchema} object.
+ */
+type AnyServiceSchema = ServiceSchema<object, ProcedureMap>;
+/**
+ * A dictionary of {@link ServiceSchema}s, where the key is the service name.
+ */
+type AnyServiceSchemaMap = Record<string, AnyServiceSchema>;
+/**
+ * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
+ * services.
+ */
+type InstantiatedServiceSchemaMap<T extends AnyServiceSchemaMap> = {
+    [K in keyof T]: T[K] extends ServiceSchema<infer S, infer P> ? Service<S, P> : never;
+};
+/**
+ * Helper to get the type definition for a specific handler of a procedure in a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcHandler<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['handler'];
+/**
+ * Helper to get the type definition for the procedure init type of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcInit<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['init']>;
+/**
+ * Helper to get the type definition for the procedure input of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcInput<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+    input: PayloadType;
+} ? Static<S['procedures'][ProcName]['input']> : never;
+/**
+ * Helper to get the type definition for the procedure output of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcOutput<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['output']>;
+/**
+ * Helper to get the type definition for the procedure errors of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcErrors<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['errors']> | Static<typeof OutputReaderErrorSchema>;
+/**
+ * Helper to get the type of procedure in a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcType<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName]['type'];
+/**
+ * A list of procedures where every procedure is "branded", as-in the procedure
+ * was created via the {@link Procedure} constructors.
+ */
+type BrandedProcedureMap<State> = Record<string, Branded<AnyProcedure<State>>>;
+/**
+ * The configuration for a service.
+ */
+interface ServiceConfiguration<State extends object> {
+    /**
+     * A factory function for creating a fresh state.
+     */
+    initializeState: (extendedContext: ServiceContext) => State;
+}
+interface SerializedProcedureSchema {
+    init: PayloadType;
+    input?: PayloadType;
+    output: PayloadType;
+    errors?: ProcedureErrorSchemaType;
+    type: 'rpc' | 'subscription' | 'upload' | 'stream';
+}
+interface SerializedServiceSchema {
+    procedures: Record<string, SerializedProcedureSchema>;
+}
+interface SerializedServerSchema {
+    handshakeSchema?: TSchema;
+    services: Record<string, SerializedServiceSchema>;
+}
+declare function serializeSchema(services: AnyServiceSchemaMap, handshakeSchema?: TSchema): SerializedServerSchema;
+/**
+ * The schema for a {@link Service}. This is used to define a service, specifically
+ * its initial state and procedures.
+ *
+ * There are two ways to define a service:
+ * 1. the {@link ServiceSchema.define} static method, which takes a configuration and
+ *    a list of procedures directly. Use this to ergonomically define a service schema
+ *    in one go. Good for smaller services, especially if they're stateless.
+ * 2. the {@link ServiceSchema.scaffold} static method, which creates a scaffold that
+ *    can be used to define procedures separately from the configuration. Use this to
+ *    better organize your service's definition, especially if it's a large service.
+ *    You can also use it in a builder pattern to define the service in a more
+ *    fluent way.
+ *
+ * See the static methods for more information and examples.
+ *
+ * When defining procedures, use the {@link Procedure} constructors to create them.
+ */
+declare class ServiceSchema<State extends object, Procedures extends ProcedureMap<State>> {
+    /**
+     * Factory function for creating a fresh state.
+     */
+    protected readonly initializeState: (extendedContext: ServiceContext) => State;
+    /**
+     * The procedures for this service.
+     */
+    readonly procedures: Procedures;
+    /**
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     */
+    protected constructor(config: ServiceConfiguration<State>, procedures: Procedures);
+    /**
+     * Creates a {@link ServiceScaffold}, which can be used to define procedures
+     * that can then be merged into a {@link ServiceSchema}, via the scaffold's
+     * `finalize` method.
+     *
+     * There are two patterns that work well with this method. The first is using
+     * it to separate the definition of procedures from the definition of the
+     * service's configuration:
+     * ```ts
+     * const MyServiceScaffold = ServiceSchema.scaffold({
+     *   initializeState: () => ({ count: 0 }),
+     * });
+     *
+     * const incrementProcedures = MyServiceScaffold.procedures({
+     *   increment: Procedure.rpc({
+     *     init: Type.Object({ amount: Type.Number() }),
+     *     output: Type.Object({ current: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       ctx.state.count += init.amount;
+     *       return Ok({ current: ctx.state.count });
+     *     }
+     *   }),
+     * })
+     *
+     * const MyService = MyServiceScaffold.finalize({
+     *   ...incrementProcedures,
+     *   // you can also directly define procedures here
+     * });
+     * ```
+     * This might be really handy if you have a very large service and you're
+     * wanting to split it over multiple files. You can define the scaffold
+     * in one file, and then import that scaffold in other files where you
+     * define procedures - and then finally import the scaffolds and your
+     * procedure objects in a final file where you finalize the scaffold into
+     * a service schema.
+     *
+     * The other way is to use it like in a builder pattern:
+     * ```ts
+     * const MyService = ServiceSchema
+     *   .scaffold({ initializeState: () => ({ count: 0 }) })
+     *   .finalize({
+     *     increment: Procedure.rpc({
+     *       init: Type.Object({ amount: Type.Number() }),
+     *       output: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   })
+     * ```
+     * Depending on your preferences, this may be a more appealing way to define
+     * a schema versus using the {@link ServiceSchema.define} method.
+     */
+    static scaffold<State extends object>(config: ServiceConfiguration<State>): ServiceScaffold<State>;
+    /**
+     * Creates a new {@link ServiceSchema} with the given configuration and procedures.
+     *
+     * All procedures must be created with the {@link Procedure} constructors.
+     *
+     * NOTE: There is an overload that lets you just provide the procedures alone if your
+     * service has no state.
+     *
+     * @param config - The configuration for this service.
+     * @param procedures - The procedures for this service.
+     *
+     * @example
+     * ```
+     * const service = ServiceSchema.define(
+     *   { initializeState: () => ({ count: 0 }) },
+     *   {
+     *     increment: Procedure.rpc({
+     *       init: Type.Object({ amount: Type.Number() }),
+     *       output: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   },
+     * );
+     * ```
+     */
+    static define<State extends object, Procedures extends BrandedProcedureMap<State>>(config: ServiceConfiguration<State>, procedures: Procedures): ServiceSchema<State, {
+        [K in keyof Procedures]: Unbranded<Procedures[K]>;
+    }>;
+    /**
+     * Creates a new {@link ServiceSchema} with the given procedures.
+     *
+     * All procedures must be created with the {@link Procedure} constructors.
+     *
+     * NOTE: There is an overload that lets you provide configuration as well,
+     * if your service has extra configuration like a state.
+     *
+     * @param procedures - The procedures for this service.
+     *
+     * @example
+     * ```
+     * const service = ServiceSchema.define({
+     *   add: Procedure.rpc({
+     *     init: Type.Object({ a: Type.Number(), b: Type.Number() }),
+     *     output: Type.Object({ result: Type.Number() }),
+     *     async handler(ctx, init) {
+     *       return Ok({ result: init.a + init.b });
+     *     }
+     *   }),
+     * });
+     */
+    static define<Procedures extends BrandedProcedureMap<Record<string, never>>>(procedures: Procedures): ServiceSchema<Record<string, never>, {
+        [K in keyof Procedures]: Unbranded<Procedures[K]>;
+    }>;
+    /**
+     * Serializes this schema's procedures into a plain object that is JSON compatible.
+     */
+    serialize(): SerializedServiceSchema;
+    /**
+     * Instantiates this schema into a {@link Service} object.
+     *
+     * You probably don't need this, usually the River server will handle this
+     * for you.
+     */
+    instantiate(extendedContext: ServiceContext): Service<State, Procedures>;
+}
+/**
+ * A scaffold for defining a service's procedures.
+ *
+ * @see {@link ServiceSchema.scaffold}
+ */
+declare class ServiceScaffold<State extends object> {
+    /**
+     * The configuration for this service.
+     */
+    protected readonly config: ServiceConfiguration<State>;
+    /**
+     * @param config - The configuration for this service.
+     */
+    constructor(config: ServiceConfiguration<State>);
+    /**
+     * Define procedures for this service. Use the {@link Procedure} constructors
+     * to create them. This returns the procedures object, which can then be
+     * passed to {@link ServiceSchema.finalize} to create a {@link ServiceSchema}.
+     *
+     * @example
+     * ```
+     * const myProcedures = MyServiceScaffold.procedures({
+     *   myRPC: Procedure.rpc({
+     *     // ...
+     *   }),
+     * });
+     *
+     * const MyService = MyServiceScaffold.finalize({
+     *   ...myProcedures,
+     * });
+     * ```
+     *
+     * @param procedures - The procedures for this service.
+     */
+    procedures<T extends BrandedProcedureMap<State>>(procedures: T): T;
+    /**
+     * Finalizes the scaffold into a {@link ServiceSchema}. This is where you
+     * provide the service's procedures and get a {@link ServiceSchema} in return.
+     *
+     * You can directly define procedures here, or you can define them separately
+     * with the {@link ServiceScaffold.procedures} method, and then pass them here.
+     *
+     * @example
+     * ```
+     * const MyService = MyServiceScaffold.finalize({
+     *  myRPC: Procedure.rpc({
+     *   // ...
+     *  }),
+     *  // e.g. from the procedures method
+     *  ...myOtherProcedures,
+     * });
+     * ```
+     */
+    finalize<T extends BrandedProcedureMap<State>>(procedures: T): ServiceSchema<State, {
+        [K in keyof T]: Unbranded<T[K]>;
+    }>;
+}
+
+export { createClientHandshakeOptions as $, AnyServiceSchemaMap as A, BaseErrorSchemaType as B, Connection as C, StreamProcedure as D, ErrResult as E, UNCAUGHT_ERROR_CODE as F, UNEXPECTED_DISCONNECT_CODE as G, INVALID_REQUEST_CODE as H, InstantiatedServiceSchemaMap as I, InputReaderErrorSchema as J, createClient as K, Client as L, ParsedMetadata as M, ProcedureHandlerContext as N, OkResult as O, PayloadType as P, Ok as Q, ReadStream as R, SessionOptions as S, Transport as T, UploadProcedure as U, ValidProcType as V, WriteStream as W, Err as X, ResultUnwrapOk as Y, ResultUnwrapErr as Z, Output as _, Session as a, createServerHandshakeOptions as a0, ServerTransportOptions as a1, TransportStatus as a2, ProvidedTransportOptions as a3, EventMap as a4, EventTypes as a5, EventHandler as a6, ProtocolError as a7, ProtocolErrorType as a8, ProcedureErrorSchemaType as b, Procedure as c, ServiceContext as d, Result as e, OutputReaderErrorSchema as f, ClientTransport as g, ProvidedClientTransportOptions as h, ProvidedServerTransportOptions as i, SerializedServerSchema as j, ServerHandshakeOptions as k, Service as l, ServiceConfiguration as m, ProcHandler as n, ProcInit as o, ProcInput as p, ProcOutput as q, ProcErrors as r, ProcType as s, ServiceSchema as t, serializeSchema as u, SerializedServiceSchema as v, SerializedProcedureSchema as w, ProcedureMap as x, RpcProcedure as y, SubscriptionProcedure as z };