@replit/river 0.208.4 → 0.209.1

package/dist/services-BFGny14R.d.ts

@@ -0,0 +1,1010 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { TNever, TObject, TLiteral, TString, TSchema, TUnion, Static } from '@sinclair/typebox';
+import { Span } from '@opentelemetry/api';
+import { c as TransportClientId } from './message-Dlsh5WDF.js';
+import { C as Connection, n as ClientHandshakeOptions, z as SessionId } from './common-yodP-WNy.js';
+import { C as ClientTransport } from './client-Cvl0bF5y.js';
+
+/**
+ * {@link 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";
+/**
+ * {@link UNEXPECTED_DISCONNECT_CODE} is the code used the stream's session
+ * disconnect unexpetedly.
+ */
+declare const UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+/**
+ * {@link INVALID_REQUEST_CODE} is the code used when a client's request is invalid.
+ */
+declare const INVALID_REQUEST_CODE = "INVALID_REQUEST";
+/**
+ * {@link CANCEL_CODE} is the code used when either server or client cancels the stream.
+ */
+declare const CANCEL_CODE = "CANCEL";
+type TLiteralString = TLiteral<string>;
+type BaseErrorSchemaType = TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+}> | TObject<{
+    code: TLiteralString;
+    message: TLiteralString | TString;
+    extras: TSchema;
+}>;
+/**
+ * A schema for cancel payloads sent from the client
+ */
+declare const CancelErrorSchema: TObject<{
+    code: TLiteral<"CANCEL">;
+    message: TString;
+}>;
+/**
+ * {@link ReaderErrorSchema} is the schema for all the built-in river errors that
+ * can be emitted to a reader (request reader on the server, and response reader
+ * on the client).
+ */
+declare const ReaderErrorSchema: TUnion<[TObject<{
+    code: TLiteral<"UNCAUGHT_ERROR">;
+    message: TString;
+}>, TObject<{
+    code: TLiteral<"UNEXPECTED_DISCONNECT">;
+    message: TString;
+}>, TObject<{
+    code: TLiteral<"INVALID_REQUEST">;
+    message: TString;
+    extras: _sinclair_typebox.TOptional<TObject<{
+        firstValidationErrors: _sinclair_typebox.TArray<TObject<{
+            path: TString;
+            message: TString;
+        }>>;
+        totalErrors: _sinclair_typebox.TNumber;
+    }>>;
+}>, TObject<{
+    code: TLiteral<"CANCEL">;
+    message: TString;
+}>]>;
+/**
+ * Represents an acceptable schema to pass to a procedure.
+ * Just a type of a schema, not an actual schema.
+ *
+ */
+type ProcedureErrorSchemaType = TNever | BaseErrorSchemaType | TUnion<Array<BaseErrorSchemaType>>;
+type NestableProcedureErrorSchemaType = BaseErrorSchemaType | TUnion<NestableProcedureErrorSchemaTypeArray>;
+interface NestableProcedureErrorSchemaTypeArray extends Array<NestableProcedureErrorSchemaType> {
+}
+type Flatten<T> = T extends BaseErrorSchemaType ? T : T extends TUnion<Array<infer U extends TSchema>> ? Flatten<U> : unknown;
+/**
+ * In the case where API consumers for some god-forsaken reason want to use
+ * arbitrarily nested unions, this helper flattens them to a single level.
+ *
+ * Note that loses some metadata information on the nested unions like
+ * nested description fields, etc.
+ *
+ * @param errType - An arbitrarily union-nested error schema.
+ * @returns The flattened error schema.
+ */
+declare function flattenErrorType<T extends NestableProcedureErrorSchemaType>(errType: T): Flatten<T>;
+
+declare const ReadableBrokenError: {
+    readonly code: "READABLE_BROKEN";
+    readonly message: "Readable was broken before it is fully consumed";
+};
+/**
+ * Similar to {@link Result} but with an extra error to handle cases where {@link Readable.break} is called
+ */
+type ReadableResult<T, E extends Static<BaseErrorSchemaType>> = Result<T, E | typeof ReadableBrokenError>;
+/**
+ * A simple {@link AsyncIterator} used in {@link Readable}
+ * that doesn't have a the extra "return" and "throw" methods, and
+ * the doesn't have a "done value" (TReturn).
+ */
+interface ReadableIterator<T, E extends Static<BaseErrorSchemaType>> {
+    next(): Promise<{
+        done: false;
+        value: ReadableResult<T, E>;
+    } | {
+        done: true;
+        value: undefined;
+    }>;
+}
+/**
+ * A {@link Readable} is an abstraction from which data is consumed from {@link Writable} source.
+ *
+ * - On the server the argument passed the procedure handler for `upload` and `stream` implements a {@link Readable} interface
+ *   so you can read client's request data.
+ * - On the client the returned value of `subscription` or `stream` invocation implements a {@link Readable} interface
+ *   so you can read server's response data.
+ *
+ * A {@link Readable} can only have one consumer (iterator or {@link collect}) for the {@link Readable}'s
+ * lifetime, in essense, reading from a {@link Readable} locks it forever.
+ */
+interface Readable<T, E extends Static<BaseErrorSchemaType>> {
+    /**
+     * {@link Readable} implements AsyncIterator API and can be consumed via
+     * for-await-of loops. Iteration locks the Readable. Exiting the loop
+     * will **not** release the lock and it'll be equivalent of calling
+     * {@link break}.
+     */
+    [Symbol.asyncIterator](): ReadableIterator<T, E>;
+    /**
+     * {@link collect} locks the {@link Readable} and returns a promise that resolves
+     * with an array of the content when the {@link Readable} is fully done. This could
+     * be due to the {@link Writable} end of the pipe closing cleanly, the procedure invocation
+     * is cancelled, or {@link break} is called.
+     */
+    collect(): Promise<Array<ReadableResult<T, E>>>;
+    /**
+     * {@link break} locks the {@link Readable} and discards any existing or future incoming data.
+     *
+     * If there is an existing reader waiting for the next value, {@link break} causes it to
+     * resolve with a {@link ReadableBrokenError} error.
+     */
+    break(): undefined;
+    /**
+     * {@link isReadable} returns true if it's safe to read from the {@link Readable}, either
+     * via iteration or {@link collect}. It returns false if the {@link Readable} is locked
+     * by a consumer (iterator or {@link collect}) or readable was broken via {@link break}.
+     */
+    isReadable(): boolean;
+}
+/**
+ * A {@link Writeable} is a an abstraction for a {@link Readable} destination to which data is written to.
+ *
+ * - On the server the argument passed the procedure handler for `subscription` and `stream` implements a {@link Writeable}
+ *   so you can write server's response data.
+ * - On the client the returned value of `upload` or `stream` invocation implements a {@link Writeable}
+ *   so you can write client's request data.
+ *
+ * Once closed, a {@link Writeable} can't be re-opened.`  `
+ */
+interface Writable<T> {
+    /**
+     * {@link write} writes a value to the pipe. An error is thrown if writing to a closed {@link Writable}.
+     */
+    write(value: T): undefined;
+    /**
+     * {@link close} signals the closure of the {@link Writeable}, informing the {@link Readable} end that
+     * all data has been transmitted and we've cleanly closed.
+     *
+     * Calling {@link close} multiple times is a no-op.
+     */
+    close(): undefined;
+    /**
+     * {@link isWritable} returns true if it's safe to call {@link write}, which
+     * means that the {@link Writable} hasn't been closed due to {@link close} being called
+     * on this {@link Writable} or the procedure invocation ending for any reason.
+     */
+    isWritable(): boolean;
+}
+
+interface CallOptions {
+    signal?: AbortSignal;
+}
+type RpcFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => Promise<Result<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>>;
+type UploadFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    reqWritable: Writable<ProcRequest<Service, ProcName>>;
+    finalize: () => Promise<Result<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>>;
+};
+type StreamFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    reqWritable: Writable<ProcRequest<Service, ProcName>>;
+    resReadable: Readable<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>;
+};
+type SubscriptionFn<Service extends AnyService, ProcName extends keyof Service['procedures']> = (reqInit: ProcInit<Service, ProcName>, options?: CallOptions) => {
+    resReadable: Readable<ProcResponse<Service, ProcName>, ProcErrors<Service, ProcName>>;
+};
+/**
+ * A helper type to transform an actual service type into a type
+ * we can case to in the proxy.
+ * @template Service - The type of the Service.
+ */
+type ServiceClient<Service extends AnyService> = {
+    [ProcName in keyof Service['procedures']]: ProcType<Service, ProcName> extends 'rpc' ? {
+        rpc: RpcFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'upload' ? {
+        upload: UploadFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'stream' ? {
+        stream: StreamFn<Service, ProcName>;
+    } : ProcType<Service, ProcName> extends 'subscription' ? {
+        subscribe: SubscriptionFn<Service, 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<any>, IS extends InstantiatedServiceSchemaMap<any, any, Services> = InstantiatedServiceSchemaMap<any, any, 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<any>>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions & {
+    handshakeOptions: ClientHandshakeOptions;
+}>): Client<ServiceSchemaMap>;
+
+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 response type for a procedure, represented as a {@link Result}
+ * type.
+ * Example:
+ * ```
+ * type Message = ResponseData<typeof client, 'serviceName', 'procedureName'>
+ * ```
+ */
+type ResponseData<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 RpcFn extends Fn;
+} ? Awaited<ReturnType<RpcFn>> : Procedure extends object & {
+    upload: infer UploadFn extends Fn;
+} ? ReturnType<UploadFn> extends {
+    finalize: (...args: never) => Promise<infer UploadOutputMessage>;
+} ? UploadOutputMessage : never : Procedure extends object & {
+    stream: infer StreamFn extends Fn;
+} ? ReturnType<StreamFn> extends {
+    resReadable: Readable<infer StreamOutputMessage, Static<BaseErrorSchemaType>>;
+} ? StreamOutputMessage : never : Procedure extends object & {
+    subscribe: infer SubscriptionFn extends Fn;
+} ? Awaited<ReturnType<SubscriptionFn>> extends {
+    resReadable: Readable<infer SubscriptionOutputMessage, Static<BaseErrorSchemaType>>;
+} ? SubscriptionOutputMessage : never : never : never : never;
+
+/**
+ * This is passed to every procedure handler and contains various context-level
+ * information and utilities.
+ */
+type ProcedureHandlerContext<State, Context, ParsedMetadata> = Context & {
+    /**
+     * State for this service as defined by the service definition.
+     */
+    state: State;
+    /**
+     * The span for this procedure call. You can use this to add attributes, events, and
+     * links to the span.
+     */
+    span: Span;
+    /**
+     * Metadata parsed on the server. See {@link createServerHandshakeOptions}
+     */
+    metadata: ParsedMetadata;
+    /**
+     * The ID of the session that sent this request.
+     */
+    sessionId: SessionId;
+    /**
+     * The ID of the client that sent this request. There may be multiple sessions per client.
+     */
+    from: TransportClientId;
+    /**
+     * This is used to cancel the procedure call from the handler and notify the client that the
+     * call was cancelled.
+     *
+     * Cancelling is not the same as closing procedure calls gracefully, please refer to
+     * the river documentation to understand the difference between the two concepts.
+     */
+    cancel: (message?: string) => ErrResult<Static<typeof CancelErrorSchema>>;
+    /**
+     * This signal is a standard [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal)
+     * triggered when the procedure invocation is done. This signal tracks the invocation/request finishing
+     * for _any_ reason, for example:
+     * - client explicit cancellation
+     * - procedure handler explicit cancellation via {@link cancel}
+     * - client session disconnect
+     * - server cancellation due to client invalid payload
+     * - invocation finishes cleanly, this depends on the type of the procedure (i.e. rpc handler return, or in a stream after the client-side has closed the request writable and the server-side has closed the response writable)
+     *
+     * You can use this to pass it on to asynchronous operations (such as fetch).
+     *
+     * You may also want to explicitly register callbacks on the
+     * ['abort' event](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/abort_event)
+     * as a way to cleanup after the request is finished.
+     *
+     * Note that (per standard AbortSignals) callbacks registered _after_ the procedure invocation
+     * is done are not triggered. In such cases, you can check the "aborted" property and cleanup
+     * immediately if needed.
+     */
+    signal: AbortSignal;
+};
+
+/**
+ * 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;
+type Cancellable<T> = T | Static<typeof CancelErrorSchema>;
+/**
+ * Procedure for a single message in both directions (1:1).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface RpcProcedure<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'rpc';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State, Context, ParsedMetadata>;
+        reqInit: Static<RequestInit>;
+    }): Promise<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+}
+/**
+ * Procedure for a client-stream (potentially preceded by an initialization message),
+ * single message from server (n:1).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template RequestData - The TypeBox schema of the request object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface UploadProcedure<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'upload';
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State, Context, ParsedMetadata>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+    }): Promise<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+}
+/**
+ * Procedure for a single message from client, stream from server (1:n).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'subscription';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State, Context, ParsedMetadata>;
+        reqInit: Static<RequestInit>;
+        resWritable: Writable<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+    }): Promise<void | undefined>;
+}
+/**
+ * Procedure for a bidirectional stream (potentially preceded by an initialization message),
+ * (n:n).
+ *
+ * @template State - The context state object.
+ * @template RequestInit - The TypeBox schema of the initialization object.
+ * @template RequestData - The TypeBox schema of the request object.
+ * @template ResponseData - The TypeBox schema of the response object.
+ * @template ResponseErr - The TypeBox schema of the error object.
+ */
+interface StreamProcedure<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'stream';
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State, Context, ParsedMetadata>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+        resWritable: Writable<Result<Static<ResponseData>, Cancellable<Static<ResponseErr>>>>;
+    }): 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<Context = object, State = object, ParsedMetadata = object> = Procedure<Context, State, ParsedMetadata, 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<Context = object, State = object, ParsedMetadata = object> = Record<string, AnyProcedure<Context, State, ParsedMetadata>>;
+/**
+ * Creates an {@link RpcProcedure}.
+ */
+declare function rpc<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: RpcProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<RpcProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, TNever>>;
+declare function rpc<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: RpcProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<RpcProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates an {@link UploadProcedure}, optionally with an initialization message.
+ */
+declare function upload<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: UploadProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<UploadProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, TNever>>;
+declare function upload<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: UploadProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<UploadProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link SubscriptionProcedure}.
+ */
+declare function subscription<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, TNever>>;
+declare function subscription<Context, State, ParsedMetadata, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link StreamProcedure}, optionally with an initialization message.
+ */
+declare function stream<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: StreamProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<StreamProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, TNever>>;
+declare function stream<Context, State, ParsedMetadata, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: StreamProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<StreamProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr>>;
+/**
+ * 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 RequestData - The TypeBox schema of the request object.
+ * @template RequestInit - The TypeBox schema of the request initialization object, if any.
+ * @template ResponseData - The TypeBox schema of the response object.
+ */
+type Procedure<Context, State, ParsedMetadata, Ty extends ValidProcType, RequestInit extends PayloadType, RequestData extends PayloadType | null, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> = {
+    type: Ty;
+} & (RequestData extends PayloadType ? Ty extends 'upload' ? UploadProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr> : Ty extends 'stream' ? StreamProcedure<Context, State, ParsedMetadata, RequestInit, RequestData, ResponseData, ResponseErr> : never : Ty extends 'rpc' ? RpcProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr> : Ty extends 'subscription' ? SubscriptionProcedure<Context, State, ParsedMetadata, RequestInit, ResponseData, ResponseErr> : 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<Context, State extends object, ParsedMetadata, Procs extends ProcedureMap<Context, State, ParsedMetadata>> {
+    readonly state: State;
+    readonly procedures: Procs;
+    [Symbol.asyncDispose]: () => Promise<void>;
+}
+/**
+ * Represents any {@link Service} object.
+ */
+type AnyService = Service<object, object, object, ProcedureMap>;
+/**
+ * Represents any {@link ServiceSchema} object.
+ */
+type AnyServiceSchema<Context extends object = object, ParsedMetadata extends object = object> = InstanceType<ReturnType<typeof createServiceSchema<Context, ParsedMetadata>>>;
+/**
+ * A dictionary of {@link ServiceSchema}s, where the key is the service name.
+ */
+type AnyServiceSchemaMap<Context extends object = object, ParsedMetadata extends object = object> = Record<string, AnyServiceSchema<Context, ParsedMetadata>>;
+/**
+ * Takes a {@link AnyServiceSchemaMap} and returns a dictionary of instantiated
+ * services.
+ */
+type InstantiatedServiceSchemaMap<Context extends object, ParsedMetadata extends object, T extends AnyServiceSchemaMap<Context, ParsedMetadata>> = {
+    [K in keyof T]: T[K] extends AnyServiceSchema<Context, ParsedMetadata> ? T[K] extends {
+        initializeState: (ctx: Context) => infer S;
+        procedures: infer P;
+    } ? Service<Context, S extends object ? S : object, ParsedMetadata, P extends ProcedureMap<Context, S extends object ? S : object, ParsedMetadata> ? P : ProcedureMap> : never : 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]['requestInit']>;
+/**
+ * Helper to get the type definition for the procedure request of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcRequest<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+    requestData: PayloadType;
+} ? Static<S['procedures'][ProcName]['requestData']> : never;
+/**
+ * Helper to get the type definition for the procedure response of a service.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcResponse<S extends AnyService, ProcName extends keyof S['procedures']> = Static<S['procedures'][ProcName]['responseData']>;
+/**
+ * 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]['responseError']> | Static<typeof ReaderErrorSchema>;
+/**
+ * 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<Context, State, ParsedMetadata> = Record<string, Branded<AnyProcedure<Context, State, ParsedMetadata>>>;
+type MaybeDisposable<State extends object> = State & {
+    [Symbol.asyncDispose]?: () => Promise<void>;
+    [Symbol.dispose]?: () => void;
+};
+/**
+ * The configuration for a service.
+ */
+interface ServiceConfiguration<Context extends object, State extends object> {
+    /**
+     * A factory function for creating a fresh state.
+     */
+    initializeState: (extendedContext: Context) => MaybeDisposable<State>;
+}
+interface SerializedProcedureSchemaProtocolv1 {
+    init?: PayloadType;
+    input: PayloadType;
+    output: PayloadType;
+    errors?: ProcedureErrorSchemaType;
+    type: 'rpc' | 'subscription' | 'upload' | 'stream';
+}
+interface SerializedServiceSchemaProtocolv1 {
+    procedures: Record<string, SerializedProcedureSchemaProtocolv1>;
+}
+interface SerializedServerSchemaProtocolv1 {
+    handshakeSchema?: TSchema;
+    services: Record<string, SerializedServiceSchemaProtocolv1>;
+}
+/**
+ * Same as {@link serializeSchema} but with a format that is compatible with
+ * protocolv1. This is useful to be able to continue to generate schemas for older
+ * clients as they are still supported.
+ */
+declare function serializeSchemaV1Compat(services: AnyServiceSchemaMap, handshakeSchema?: TSchema): SerializedServerSchemaProtocolv1;
+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>;
+}
+/**
+ * Serializes a server schema into a plain object that is JSON compatible.
+ */
+declare function serializeSchema(services: AnyServiceSchemaMap, handshakeSchema?: TSchema): SerializedServerSchema;
+/**
+ * Creates a ServiceSchema class that can be used to define services with their initial state and procedures.
+ * This is a factory function that returns a ServiceSchema class constructor bound to the specified Context type.
+ *
+ * @template Context - The context type that will be available to all procedures in services created with this schema.
+ * @returns A ServiceSchema class constructor with static methods for defining services.
+ *
+ * @example
+ * ```ts
+ * // Create a ServiceSchema class for your context type
+ * const ServiceSchema = createServiceSchema<{ userId: string }>();
+ *
+ * // Define a simple stateless service
+ * const mathService = ServiceSchema.define({
+ *   add: Procedure.rpc({
+ *     requestInit: Type.Object({ a: Type.Number(), b: Type.Number() }),
+ *     responseData: Type.Object({ result: Type.Number() }),
+ *     async handler(ctx, init) {
+ *       return Ok({ result: init.a + init.b });
+ *     }
+ *   }),
+ *   getUserId: Procedure.rpc({
+ *     requestInit: Type.Object({}),
+ *     responseData: Type.Object({ id: Type.String() }),
+ *     async handler(ctx) {
+ *       return Ok({ id: ctx.userId });
+ *     }
+ *   }),
+ * });
+ * ```
+ *
+ * There are two main ways to define services with the returned ServiceSchema class:
+ *
+ * 1. **ServiceSchema.define()** - Takes a configuration and procedures directly.
+ *    Use this for smaller services or when you want to define everything in one place.
+ *
+ * 2. **ServiceSchema.scaffold()** - Creates a scaffold that can be used to define
+ *    procedures separately from the configuration. Use this for larger services or
+ *    when you want to organize procedures across multiple files.
+ *
+ * When defining procedures, always use the {@link Procedure} constructors to create them.
+ */
+declare function createServiceSchema<Context extends object = object, ParsedMetadata extends object = object>(): {
+    new <State extends object, Procedures extends ProcedureMap<Context, State, ParsedMetadata>>(config: ServiceConfiguration<Context, State>, procedures: Procedures): {
+        /**
+         * Factory function for creating a fresh state.
+         */
+        readonly initializeState: (extendedContext: Context) => MaybeDisposable<State>;
+        /**
+         * The procedures for this service.
+         */
+        readonly procedures: Procedures;
+        /**
+         * Serializes this schema's procedures into a plain object that is JSON compatible.
+         */
+        serialize(): SerializedServiceSchema;
+        /**
+         * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+         * protocol v1. This is useful to be able to continue to generate schemas for older
+         * clients as they are still supported.
+         */
+        serializeV1Compat(): SerializedServiceSchemaProtocolv1;
+        /**
+         * 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: Context): Service<Context, State, ParsedMetadata, 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({
+     *     requestInit: Type.Object({ amount: Type.Number() }),
+     *     responseData: 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({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: 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.
+     */
+    scaffold<State_1 extends object>(config: ServiceConfiguration<Context, State_1>): ServiceScaffold<Context, State_1, ParsedMetadata>;
+    /**
+     * 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({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   },
+     * );
+     * ```
+     */
+    define<State_2 extends object, Procedures_1 extends BrandedProcedureMap<Context, State_2, ParsedMetadata>>(config: ServiceConfiguration<Context, State_2>, procedures: Procedures_1): {
+        /**
+         * Factory function for creating a fresh state.
+         */
+        readonly initializeState: (extendedContext: Context) => MaybeDisposable<State_2>;
+        /**
+         * The procedures for this service.
+         */
+        readonly procedures: { [K in keyof Procedures_1]: Unbranded<Procedures_1[K]>; };
+        /**
+         * Serializes this schema's procedures into a plain object that is JSON compatible.
+         */
+        serialize(): SerializedServiceSchema;
+        /**
+         * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+         * protocol v1. This is useful to be able to continue to generate schemas for older
+         * clients as they are still supported.
+         */
+        serializeV1Compat(): SerializedServiceSchemaProtocolv1;
+        /**
+         * 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: Context): Service<Context, State_2, ParsedMetadata, { [K in keyof Procedures_1]: Unbranded<Procedures_1[K]>; }>;
+    };
+    /**
+     * 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({
+     *       requestInit: Type.Object({ amount: Type.Number() }),
+     *       responseData: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, init) {
+     *         ctx.state.count += init.amount;
+     *         return Ok({ current: ctx.state.count });
+     *       }
+     *     }),
+     *   },
+     * );
+     * ```
+     */
+    define<Procedures_2 extends BrandedProcedureMap<Context, object, ParsedMetadata>>(procedures: Procedures_2): {
+        /**
+         * Factory function for creating a fresh state.
+         */
+        readonly initializeState: (extendedContext: Context) => MaybeDisposable<object>;
+        /**
+         * The procedures for this service.
+         */
+        readonly procedures: { [K_1 in keyof Procedures_2]: Unbranded<Procedures_2[K_1]>; };
+        /**
+         * Serializes this schema's procedures into a plain object that is JSON compatible.
+         */
+        serialize(): SerializedServiceSchema;
+        /**
+         * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+         * protocol v1. This is useful to be able to continue to generate schemas for older
+         * clients as they are still supported.
+         */
+        serializeV1Compat(): SerializedServiceSchemaProtocolv1;
+        /**
+         * 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: Context): Service<Context, object, ParsedMetadata, { [K_1 in keyof Procedures_2]: Unbranded<Procedures_2[K_1]>; }>;
+    };
+};
+/**
+ * A scaffold for defining a service's procedures.
+ *
+ * @see {@link ServiceSchema.scaffold}
+ */
+declare class ServiceScaffold<Context extends object, State extends object, ParsedMetadata extends object> {
+    /**
+     * The configuration for this service.
+     */
+    protected readonly config: ServiceConfiguration<Context, State>;
+    /**
+     * @param config - The configuration for this service.
+     */
+    constructor(config: ServiceConfiguration<Context, 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<Context, State, ParsedMetadata>>(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<Context, State, ParsedMetadata>>(procedures: T): {
+        /**
+         * Factory function for creating a fresh state.
+         */
+        readonly initializeState: (extendedContext: Context) => MaybeDisposable<State>;
+        /**
+         * The procedures for this service.
+         */
+        readonly procedures: { [K in keyof T]: Unbranded<T[K]>; };
+        /**
+         * Serializes this schema's procedures into a plain object that is JSON compatible.
+         */
+        serialize(): SerializedServiceSchema;
+        /**
+         * Same as {@link ServiceSchema.serialize}, but with a format that is compatible with
+         * protocol v1. This is useful to be able to continue to generate schemas for older
+         * clients as they are still supported.
+         */
+        serializeV1Compat(): SerializedServiceSchemaProtocolv1;
+        /**
+         * 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: Context): Service<Context, State, ParsedMetadata, { [K in keyof T]: Unbranded<T[K]>; }>;
+    };
+}
+
+export { type AnyServiceSchemaMap as A, UNEXPECTED_DISCONNECT_CODE as B, INVALID_REQUEST_CODE as C, CANCEL_CODE as D, ReaderErrorSchema as E, type BaseErrorSchemaType as F, createClient as G, type Client as H, type InstantiatedServiceSchemaMap as I, Err as J, type Result as K, type ErrResult as L, type OkResult as M, type ResultUnwrapOk as N, Ok as O, type ProcedureHandlerContext as P, type ResultUnwrapErr as Q, type RpcProcedure as R, type Service as S, type ResponseData as T, type UploadProcedure as U, type ValidProcType as V, type Writable as W, type ReadableIterator as X, type ReadableResult as Y, type PayloadType as a, type AnyProcedure as b, type ServiceConfiguration as c, type ProcHandler as d, type ProcInit as e, type ProcRequest as f, type ProcResponse as g, type ProcErrors as h, type ProcType as i, createServiceSchema as j, type SerializedServerSchema as k, type SerializedServiceSchema as l, type SerializedProcedureSchema as m, serializeSchemaV1Compat as n, type SerializedServerSchemaProtocolv1 as o, type SerializedServiceSchemaProtocolv1 as p, type SerializedProcedureSchemaProtocolv1 as q, type ProcedureMap as r, serializeSchema as s, type SubscriptionProcedure as t, type StreamProcedure as u, type Readable as v, Procedure as w, type ProcedureErrorSchemaType as x, flattenErrorType as y, UNCAUGHT_ERROR_CODE as z };