@replit/river 0.200.0-rc.2 → 0.200.0-rc.20

package/dist/services-aa49a9fb.d.ts

@@ -0,0 +1,811 @@
+import * as _sinclair_typebox from '@sinclair/typebox';
+import { Static, TObject, TUnion, TString, TSchema, TLiteral, TNever } from '@sinclair/typebox';
+import { C as Connection, p as ClientHandshakeOptions, u as ProcedureHandlerContext, o as ServiceContext } from './context-9c907028.js';
+import { c as TransportClientId } from './message-59fe53e1.js';
+import { C as ClientTransport } from './client-75090f07.js';
+
+declare const ReadableBrokenError: Static<BaseErrorSchemaType>;
+/**
+ * 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, 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;
+/**
+ * Unwrap a {@link Result} type and return the payload if successful,
+ * otherwise throws an error.
+ * @param result - The result to unwrap.
+ * @throws Will throw an error if the result is not ok.
+ */
+declare function unwrapOrThrow<T, Err extends Static<BaseErrorSchemaType>>(result: Result<T, Err>): T;
+/**
+ * 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;
+
+/**
+ * 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;
+/**
+ * {@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";
+/**
+ * {@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: _sinclair_typebox.TObject<{
+    code: TUnion<[_sinclair_typebox.TLiteral<"UNCAUGHT_ERROR">, _sinclair_typebox.TLiteral<"UNEXPECTED_DISCONNECT">, _sinclair_typebox.TLiteral<"INVALID_REQUEST">, _sinclair_typebox.TLiteral<"CANCEL">]>;
+    message: _sinclair_typebox.TString;
+}>;
+type ProcedureErrorUnionSchema0 = TUnion<Array<BaseErrorSchemaType>>;
+type ProcedureErrorUnionSchema1 = TUnion<Array<ProcedureErrorUnionSchema0 | BaseErrorSchemaType>>;
+type ProcedureErrorUnionSchema2 = TUnion<Array<ProcedureErrorUnionSchema1 | ProcedureErrorUnionSchema0 | BaseErrorSchemaType>>;
+/**
+ * Represents an acceptable schema to pass to a procedure.
+ * Just a type of a schema, not an actual schema.
+ */
+type ProcedureErrorSchemaType = ProcedureErrorUnionSchema2 | BaseErrorSchemaType | TNever;
+/**
+ * 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<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'rpc';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+    }): Promise<Result<Static<ResponseData>, 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<State, 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>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+    }): Promise<Result<Static<ResponseData>, 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<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType> {
+    type: 'subscription';
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler(param: {
+        ctx: ProcedureHandlerContext<State>;
+        reqInit: Static<RequestInit>;
+        resWritable: Writable<Result<Static<ResponseData>, 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<State, 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>;
+        reqInit: Static<RequestInit>;
+        reqReadable: Readable<Static<RequestData>, Static<typeof ReaderErrorSchema>>;
+        resWritable: Writable<Result<Static<ResponseData>, 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<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, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: RpcProcedure<State, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<RpcProcedure<State, RequestInit, ResponseData, TNever>>;
+declare function rpc<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: RpcProcedure<State, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<RpcProcedure<State, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates an {@link UploadProcedure}, optionally with an initialization message.
+ */
+declare function upload<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: UploadProcedure<State, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<UploadProcedure<State, RequestInit, RequestData, ResponseData, TNever>>;
+declare function upload<State, 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<State, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<UploadProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link SubscriptionProcedure}.
+ */
+declare function subscription<State, RequestInit extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: SubscriptionProcedure<State, RequestInit, ResponseData, TNever>['handler'];
+}): Branded<SubscriptionProcedure<State, RequestInit, ResponseData, TNever>>;
+declare function subscription<State, RequestInit extends PayloadType, ResponseData extends PayloadType, ResponseErr extends ProcedureErrorSchemaType>(def: {
+    requestInit: RequestInit;
+    responseData: ResponseData;
+    responseError: ResponseErr;
+    description?: string;
+    handler: SubscriptionProcedure<State, RequestInit, ResponseData, ResponseErr>['handler'];
+}): Branded<SubscriptionProcedure<State, RequestInit, ResponseData, ResponseErr>>;
+/**
+ * Creates a {@link StreamProcedure}, optionally with an initialization message.
+ */
+declare function stream<State, RequestInit extends PayloadType, RequestData extends PayloadType, ResponseData extends PayloadType>(def: {
+    requestInit: RequestInit;
+    requestData: RequestData;
+    responseData: ResponseData;
+    responseError?: never;
+    description?: string;
+    handler: StreamProcedure<State, RequestInit, RequestData, ResponseData, TNever>['handler'];
+}): Branded<StreamProcedure<State, RequestInit, RequestData, ResponseData, TNever>>;
+declare function stream<State, 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<State, RequestInit, RequestData, ResponseData, ResponseErr>['handler'];
+}): Branded<StreamProcedure<State, 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<State, 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<State, RequestInit, RequestData, ResponseData, ResponseErr> : Ty extends 'stream' ? StreamProcedure<State, RequestInit, RequestData, ResponseData, ResponseErr> : never : Ty extends 'rpc' ? RpcProcedure<State, RequestInit, ResponseData, ResponseErr> : Ty extends 'subscription' ? SubscriptionProcedure<State, 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<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]['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<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 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;
+/**
+ * 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({
+     *     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.
+     */
+    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({
+     *       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 });
+     *       }
+     *     }),
+     *   },
+     * );
+     * ```
+     */
+    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({
+     *     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 });
+     *     }
+     *   }),
+     * });
+     */
+    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;
+    /**
+     * 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: 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 { AnyServiceSchemaMap as A, BaseErrorSchemaType as B, UNCAUGHT_ERROR_CODE as C, UNEXPECTED_DISCONNECT_CODE as D, INVALID_REQUEST_CODE as E, CANCEL_CODE as F, createClient as G, Client as H, InstantiatedServiceSchemaMap as I, Err as J, unwrapOrThrow as K, ErrResult as L, OkResult as M, ResultUnwrapOk as N, Ok as O, PayloadType as P, ResultUnwrapErr as Q, Readable as R, Service as S, ResponseData as T, UploadProcedure as U, ValidProcType as V, Writable as W, ReadableIterator as a, ReadableResult as b, ProcedureErrorSchemaType as c, Procedure as d, Result as e, ReaderErrorSchema as f, ServiceConfiguration as g, ProcHandler as h, ProcInit as i, ProcRequest as j, ProcResponse as k, ProcErrors as l, ProcType as m, ServiceSchema as n, SerializedServerSchema as o, SerializedServiceSchema as p, SerializedProcedureSchema as q, serializeSchemaV1Compat as r, serializeSchema as s, SerializedServerSchemaProtocolv1 as t, SerializedServiceSchemaProtocolv1 as u, SerializedProcedureSchemaProtocolv1 as v, ProcedureMap as w, RpcProcedure as x, SubscriptionProcedure as y, StreamProcedure as z };