@replit/river 0.18.5 → 0.19.2

package/dist/services-5fc5712d.d.ts

@@ -0,0 +1,736 @@
+import { Static, TObject, TUnion, TString, TSchema, TNever, TLiteral } from '@sinclair/typebox';
+import { ClientTransport } from './transport/index.js';
+import { Pushable } from 'it-pushable';
+import { C as Connection, T as TransportClientId, a as Session, b as ParsedHandshakeMetadata } from './index-e2513701.js';
+
+type AsyncIter<T> = AsyncGenerator<T, T>;
+/**
+ * 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: (input: Static<ProcInput<Router, ProcName>>) => Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>;
+    } : ProcType<Router, ProcName> extends 'upload' ? ProcHasInit<Router, ProcName> extends true ? {
+        upload: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
+            Pushable<Static<ProcInput<Router, ProcName>>>,
+            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
+        ]>;
+    } : {
+        upload: () => Promise<[
+            Pushable<Static<ProcInput<Router, ProcName>>>,
+            Promise<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>
+        ]>;
+    } : ProcType<Router, ProcName> extends 'stream' ? ProcHasInit<Router, ProcName> extends true ? {
+        stream: (init: Static<ProcInit<Router, ProcName>>) => Promise<[
+            Pushable<Static<ProcInput<Router, ProcName>>>,
+            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
+            () => void
+        ]>;
+    } : {
+        stream: () => Promise<[
+            Pushable<Static<ProcInput<Router, ProcName>>>,
+            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
+            () => void
+        ]>;
+    } : ProcType<Router, ProcName> extends 'subscription' ? {
+        subscribe: (input: Static<ProcInput<Router, ProcName>>) => Promise<[
+            AsyncIter<Result<Static<ProcOutput<Router, ProcName>>, Static<ProcErrors<Router, ProcName>>>>,
+            () => void
+        ]>;
+    } : 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.
+ * @returns The client for the server.
+ */
+declare const createClient: <ServiceSchemaMap extends AnyServiceSchemaMap>(transport: ClientTransport<Connection>, serverId: TransportClientId, providedClientOptions?: Partial<ClientOptions>) => Client<ServiceSchemaMap, InstantiatedServiceSchemaMap<ServiceSchemaMap>>;
+
+type TLiteralString = TLiteral<string>;
+type RiverErrorSchema = TObject<{
+    code: TLiteralString | TUnion<Array<TLiteralString>>;
+    message: TLiteralString | TString;
+}> | TObject<{
+    code: TLiteralString | TUnion<Array<TLiteralString>>;
+    message: TLiteralString | TString;
+    extras: TSchema;
+}>;
+type RiverError = TUnion<Array<RiverErrorSchema>> | RiverErrorSchema | TNever;
+declare const UNCAUGHT_ERROR = "UNCAUGHT_ERROR";
+declare const RiverUncaughtSchema: TObject<{
+    code: TUnion<[TLiteral<"UNCAUGHT_ERROR">, TLiteral<"UNEXPECTED_DISCONNECT">]>;
+    message: TString;
+}>;
+type Result<T, E> = {
+    ok: true;
+    payload: T;
+} | {
+    ok: false;
+    payload: E;
+};
+declare function Ok<const T, const E>(payload: T): Result<T, E>;
+declare function Err<const T, const E>(error: E): Result<T, E>;
+/**
+ * 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 E> ? E : 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;
+} ? Awaited<ReturnType<UploadHandler>> extends [
+    infer __UploadInputMessage,
+    infer UploadOutputMessage
+] ? Awaited<UploadOutputMessage> : never : Procedure extends object & {
+    stream: infer StreamHandler extends Fn;
+} ? Awaited<ReturnType<StreamHandler>> extends [
+    infer __StreamInputMessage,
+    AsyncGenerator<infer StreamOutputMessage>,
+    infer __StreamCloseHandle
+] ? StreamOutputMessage : never : Procedure extends object & {
+    subscribe: infer SubscriptionHandler extends Fn;
+} ? Awaited<ReturnType<SubscriptionHandler>> extends [
+    AsyncGenerator<infer SubscriptionOutputMessage>,
+    infer __SubscriptionCloseHandle
+] ? SubscriptionOutputMessage : never : never : never : never;
+
+/**
+ * The context for services/procedures. This is used only on
+ * the server.
+ *
+ * An important detail is that the state prop is always on
+ * this interface and it shouldn't be changed, removed, or
+ * extended. This prop is for the state of a service.
+ *
+ * You should use declaration merging to extend this interface
+ * with whatever you need. For example, if you need to access
+ * a database, you could do:
+ *
+ * ```ts
+ * declare module '@replit/river' {
+ *   interface ServiceContext {
+ *     db: Database;
+ *   }
+ * }
+ * ```
+ */
+interface ServiceContext {
+}
+/**
+ * The {@link ServiceContext} with state. This is what is passed to procedures.
+ */
+type ServiceContextWithState<State> = ServiceContext & {
+    state: State;
+};
+type ServiceContextWithTransportInfo<State> = ServiceContext & {
+    state: Omit<State, typeof Symbol.dispose>;
+    to: TransportClientId;
+    from: TransportClientId;
+    streamId: string;
+    session: Session<Connection> & {
+        metadata: ParsedHandshakeMetadata;
+    };
+};
+
+/**
+ * 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;
+/**
+ * Represents results from a {@link Procedure}. Might come from inside a stream or
+ * from a single message.
+ */
+type ProcedureResult<O extends PayloadType, E extends RiverError> = Result<Static<O>, Static<E> | Static<typeof RiverUncaughtSchema>>;
+/**
+ * Procedure for a single message in both directions (1:1).
+ *
+ * @template State - The context state object.
+ * @template I - The TypeBox schema of the input object.
+ * @template O - The TypeBox schema of the output object.
+ * @template E - The TypeBox schema of the error object.
+ */
+interface RPCProcedure<State, I extends PayloadType, O extends PayloadType, E extends RiverError> {
+    type: 'rpc';
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, input: Static<I>): Promise<ProcedureResult<O, E>>;
+}
+/**
+ * Procedure for a client-stream (potentially preceded by an initialization message),
+ * single message from server (n:1).
+ *
+ * @template State - The context state object.
+ * @template I - The TypeBox schema of the input object.
+ * @template O - The TypeBox schema of the output object.
+ * @template E - The TypeBox schema of the error object.
+ * @template Init - The TypeBox schema of the input initialization object, if any.
+ */
+type UploadProcedure<State, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null> = Init extends PayloadType ? {
+    type: 'upload';
+    init: Init;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>): Promise<ProcedureResult<O, E>>;
+} : {
+    type: 'upload';
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>): Promise<ProcedureResult<O, E>>;
+};
+/**
+ * Procedure for a single message from client, stream from server (1:n).
+ *
+ * @template State - The context state object.
+ * @template I - The TypeBox schema of the input object.
+ * @template O - The TypeBox schema of the output object.
+ * @template E - The TypeBox schema of the error object.
+ */
+interface SubscriptionProcedure<State, I extends PayloadType, O extends PayloadType, E extends RiverError> {
+    type: 'subscription';
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, input: Static<I>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
+}
+/**
+ * Procedure for a bidirectional stream (potentially preceded by an initialization message),
+ * (n:n).
+ *
+ * @template State - The context state object.
+ * @template I - The TypeBox schema of the input object.
+ * @template O - The TypeBox schema of the output object.
+ * @template E - The TypeBox schema of the error object.
+ * @template Init - The TypeBox schema of the input initialization object, if any.
+ */
+type StreamProcedure<State, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null> = Init extends PayloadType ? {
+    type: 'stream';
+    init: Init;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, init: Static<Init>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
+} : {
+    type: 'stream';
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler(context: ServiceContextWithTransportInfo<State>, input: AsyncIterableIterator<Static<I>>, output: Pushable<ProcedureResult<O, E>>): Promise<(() => void) | void>;
+};
+/**
+ * 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, RiverError, PayloadType | null>;
+/**
+ * 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, I extends PayloadType, O extends PayloadType>(def: {
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: RPCProcedure<State, I, O, TNever>['handler'];
+}): Branded<RPCProcedure<State, I, O, TNever>>;
+declare function rpc<State, I extends PayloadType, O extends PayloadType, E extends RiverError>(def: {
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: RPCProcedure<State, I, O, E>['handler'];
+}): Branded<RPCProcedure<State, I, O, E>>;
+/**
+ * Creates an {@link UploadProcedure}, optionally with an initialization message.
+ */
+declare function upload<State, I extends PayloadType, O extends PayloadType, Init extends PayloadType>(def: {
+    init: Init;
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: UploadProcedure<State, I, O, TNever, Init>['handler'];
+}): Branded<UploadProcedure<State, I, O, TNever, Init>>;
+declare function upload<State, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType>(def: {
+    init: Init;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: UploadProcedure<State, I, O, E, Init>['handler'];
+}): Branded<UploadProcedure<State, I, O, E, Init>>;
+declare function upload<State, I extends PayloadType, O extends PayloadType>(def: {
+    init?: never;
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: UploadProcedure<State, I, O, TNever>['handler'];
+}): Branded<UploadProcedure<State, I, O, TNever>>;
+declare function upload<State, I extends PayloadType, O extends PayloadType, E extends RiverError>(def: {
+    init?: never;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: UploadProcedure<State, I, O, E>['handler'];
+}): Branded<UploadProcedure<State, I, O, E>>;
+/**
+ * Creates a {@link SubscriptionProcedure}.
+ */
+declare function subscription<State, I extends PayloadType, O extends PayloadType>(def: {
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: SubscriptionProcedure<State, I, O, TNever>['handler'];
+}): Branded<SubscriptionProcedure<State, I, O, TNever>>;
+declare function subscription<State, I extends PayloadType, O extends PayloadType, E extends RiverError>(def: {
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: SubscriptionProcedure<State, I, O, E>['handler'];
+}): Branded<SubscriptionProcedure<State, I, O, E>>;
+/**
+ * Creates a {@link StreamProcedure}, optionally with an initialization message.
+ */
+declare function stream<State, I extends PayloadType, O extends PayloadType, Init extends PayloadType>(def: {
+    init: Init;
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: StreamProcedure<State, I, O, TNever, Init>['handler'];
+}): Branded<StreamProcedure<State, I, O, TNever, Init>>;
+declare function stream<State, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType>(def: {
+    init: Init;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: StreamProcedure<State, I, O, E, Init>['handler'];
+}): Branded<StreamProcedure<State, I, O, E, Init>>;
+declare function stream<State, I extends PayloadType, O extends PayloadType>(def: {
+    init?: never;
+    input: I;
+    output: O;
+    errors?: never;
+    description?: string;
+    handler: StreamProcedure<State, I, O, TNever>['handler'];
+}): Branded<StreamProcedure<State, I, O, TNever>>;
+declare function stream<State, I extends PayloadType, O extends PayloadType, E extends RiverError>(def: {
+    init?: never;
+    input: I;
+    output: O;
+    errors: E;
+    description?: string;
+    handler: StreamProcedure<State, I, O, E>['handler'];
+}): Branded<StreamProcedure<State, I, O, E>>;
+/**
+ * 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 I - The TypeBox schema of the input object.
+ * @template O - The TypeBox schema of the output object.
+ * @template Init - The TypeBox schema of the input initialization object, if any.
+ */
+type Procedure<State, Ty extends ValidProcType, I extends PayloadType, O extends PayloadType, E extends RiverError, Init extends PayloadType | null = null> = {
+    type: Ty;
+} & (Init extends PayloadType ? Ty extends 'upload' ? UploadProcedure<State, I, O, E, Init> : Ty extends 'stream' ? StreamProcedure<State, I, O, E, Init> : never : Ty extends 'rpc' ? RPCProcedure<State, I, O, E> : Ty extends 'upload' ? UploadProcedure<State, I, O, E> : Ty extends 'subscription' ? SubscriptionProcedure<State, I, O, E> : Ty extends 'stream' ? StreamProcedure<State, I, O, E> : 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 whether the type definition for the procedure contains an init type.
+ * @template S - The service.
+ * @template ProcName - The name of the procedure.
+ */
+type ProcHasInit<S extends AnyService, ProcName extends keyof S['procedures']> = S['procedures'][ProcName] extends {
+    init: PayloadType;
+} ? true : false;
+/**
+ * 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']> = S['procedures'][ProcName] extends {
+    init: PayloadType;
+} ? S['procedures'][ProcName]['init'] : never;
+/**
+ * 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]['input'];
+/**
+ * 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']> = 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']> = TUnion<[S['procedures'][ProcName]['errors'], typeof RiverUncaughtSchema]>;
+/**
+ * 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: () => State;
+}
+interface SerializedServiceSchema {
+    procedures: Record<string, {
+        input: PayloadType;
+        output: PayloadType;
+        errors?: RiverError;
+        type: 'rpc' | 'subscription' | 'upload' | 'stream';
+        init?: PayloadType;
+    }>;
+}
+type SerializedServerSchema = Record<string, SerializedServiceSchema>;
+declare function serializeSchema(services: AnyServiceSchemaMap): 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: () => 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({
+     *     input: Type.Object({ amount: Type.Number() }),
+     *     output: Type.Object({ current: Type.Number() }),
+     *     async handler(ctx, input) {
+     *       ctx.state.count += input.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({
+     *       input: Type.Object({ amount: Type.Number() }),
+     *       output: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, input) {
+     *         ctx.state.count += input.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({
+     *       input: Type.Object({ amount: Type.Number() }),
+     *       output: Type.Object({ current: Type.Number() }),
+     *       async handler(ctx, input) {
+     *         ctx.state.count += input.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({
+     *     input: Type.Object({ a: Type.Number(), b: Type.Number() }),
+     *     output: Type.Object({ result: Type.Number() }),
+     *     async handler(ctx, input) {
+     *       return Ok({ result: input.a + input.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(): 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, Output as B, Client as C, Err as E, InstantiatedServiceSchemaMap as I, Ok as O, PayloadType as P, RiverError as R, ServiceContext as S, UploadProcedure as U, ValidProcType as V, Procedure as a, Result as b, RiverUncaughtSchema as c, ProcedureResult as d, Service as e, ServiceConfiguration as f, ProcHandler as g, ProcInit as h, ProcInput as i, ProcOutput as j, ProcErrors as k, ProcType as l, ServiceSchema as m, SerializedServerSchema as n, ProcedureMap as o, RPCProcedure as p, SubscriptionProcedure as q, StreamProcedure as r, serializeSchema as s, createClient as t, ServiceContextWithState as u, ServiceContextWithTransportInfo as v, UNCAUGHT_ERROR as w, RiverErrorSchema as x, ResultUnwrapOk as y, ResultUnwrapErr as z };