@orpc/server 0.0.0-next.2ba0691 → 0.0.0-next.31590a1

package/dist/next.js

@@ -0,0 +1,39 @@
+import {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+} from "./chunk-EYGVJA7A.js";
+import "./chunk-CVIWJKJC.js";
+import "./chunk-NOA3GBJQ.js";
+import "./chunk-OXB4YX67.js";
+
+// src/adapters/next/serve.ts
+import { value } from "@orpc/shared";
+function serve(handler, ...[options]) {
+  const main = async (req) => {
+    const context = await value(options?.context ?? {}, req);
+    const { matched, response } = await handler.handle(req, { ...options, context });
+    if (matched) {
+      return response;
+    }
+    return new Response(`Cannot find a matching procedure for ${req.url}`, { status: 404 });
+  };
+  return {
+    GET: main,
+    POST: main,
+    PUT: main,
+    PATCH: main,
+    DELETE: main
+  };
+}
+export {
+  RPCHandler,
+  fetchReToStandardBody,
+  fetchRequestToStandardRequest,
+  serve,
+  standardBodyToFetchBody,
+  standardResponseToFetchResponse
+};
+//# sourceMappingURL=next.js.map

package/dist/node.js

@@ -0,0 +1,175 @@
+import {
+  RPCCodec,
+  RPCMatcher,
+  StandardHandler
+} from "./chunk-CVIWJKJC.js";
+import "./chunk-NOA3GBJQ.js";
+import "./chunk-OXB4YX67.js";
+
+// src/adapters/node/utils.ts
+import { Buffer, File } from "node:buffer";
+import { Readable } from "node:stream";
+import { once } from "@orpc/shared";
+import cd from "content-disposition";
+function nodeHttpToStandardRequest(req, res) {
+  const method = req.method ?? "GET";
+  const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
+  const host = req.headers.host ?? "localhost";
+  const url = new URL(req.originalUrl ?? req.url ?? "/", `${protocol}//${host}`);
+  return {
+    raw: { request: req, response: res },
+    method,
+    url,
+    headers: req.headers,
+    body: once(() => {
+      return nodeHttpRequestToStandardBody(req);
+    }),
+    get signal() {
+      const signal = nodeHttpResponseToAbortSignal(res);
+      Object.defineProperty(this, "signal", { value: signal, writable: true });
+      return signal;
+    },
+    set signal(value) {
+      Object.defineProperty(this, "signal", { value, writable: true });
+    }
+  };
+}
+function nodeHttpResponseSendStandardResponse(res, standardResponse) {
+  return new Promise((resolve, reject) => {
+    res.on("error", reject);
+    res.on("finish", resolve);
+    if (standardResponse.body === void 0) {
+      res.writeHead(standardResponse.status, standardResponse.headers);
+      res.end();
+      return;
+    }
+    if (standardResponse.body instanceof Blob) {
+      const resHeaders = {
+        ...standardResponse.headers,
+        "content-type": standardResponse.body.type,
+        "content-length": standardResponse.body.size.toString()
+      };
+      if (!standardResponse.headers["content-disposition"] && standardResponse.body instanceof Blob) {
+        resHeaders["content-disposition"] = cd(standardResponse.body instanceof File ? standardResponse.body.name : "blob");
+      }
+      res.writeHead(standardResponse.status, resHeaders);
+      Readable.fromWeb(
+        standardResponse.body.stream()
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof FormData) {
+      const response = new Response(standardResponse.body);
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": response.headers.get("content-type")
+      });
+      Readable.fromWeb(
+        response.body
+        // Conflict between types=node and lib=dom so we need to cast it
+      ).pipe(res);
+      return;
+    }
+    if (standardResponse.body instanceof URLSearchParams) {
+      res.writeHead(standardResponse.status, {
+        ...standardResponse.headers,
+        "content-type": "application/x-www-form-urlencoded"
+      });
+      const string2 = standardResponse.body.toString();
+      res.end(string2);
+      return;
+    }
+    res.writeHead(standardResponse.status, {
+      ...standardResponse.headers,
+      "content-type": "application/json"
+    });
+    const string = JSON.stringify(standardResponse.body);
+    res.end(string);
+  });
+}
+async function nodeHttpRequestToStandardBody(req) {
+  const method = req.method ?? "GET";
+  if (method === "GET" || method === "HEAD") {
+    return void 0;
+  }
+  const contentDisposition = req.headers["content-disposition"];
+  const fileName = contentDisposition ? cd.parse(contentDisposition).parameters.filename : void 0;
+  const contentType = req.headers["content-type"];
+  if (fileName) {
+    return await streamToFile(req, fileName, contentType || "application/octet-stream");
+  }
+  if (!contentType || contentType.startsWith("application/json")) {
+    const text = await streamToString(req);
+    if (!text) {
+      return void 0;
+    }
+    return JSON.parse(text);
+  }
+  if (contentType.startsWith("multipart/form-data")) {
+    return await streamToFormData(req, contentType);
+  }
+  if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    const text = await streamToString(req);
+    return new URLSearchParams(text);
+  }
+  if (contentType.startsWith("text/")) {
+    return await streamToString(req);
+  }
+  return streamToFile(req, "blob", contentType);
+}
+function streamToFormData(stream, contentType) {
+  const response = new Response(stream, {
+    // Conflict between types=node and lib=dom so we need to cast it
+    headers: {
+      "content-type": contentType
+    }
+  });
+  return response.formData();
+}
+async function streamToString(stream) {
+  let string = "";
+  for await (const chunk of stream) {
+    string += chunk.toString();
+  }
+  return string;
+}
+async function streamToFile(stream, fileName, contentType) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return new File([Buffer.concat(chunks)], fileName, { type: contentType });
+}
+function nodeHttpResponseToAbortSignal(res) {
+  const controller = new AbortController();
+  res.on("close", () => {
+    controller.abort();
+  });
+  return controller.signal;
+}
+
+// src/adapters/node/rpc-handler.ts
+var RPCHandler = class {
+  standardHandler;
+  constructor(router, options) {
+    const codec = options?.codec ?? new RPCCodec();
+    const matcher = options?.matcher ?? new RPCMatcher();
+    this.standardHandler = new StandardHandler(router, matcher, codec, options);
+  }
+  async handle(req, res, ...rest) {
+    const standardRequest = nodeHttpToStandardRequest(req, res);
+    const result = await this.standardHandler.handle(standardRequest, ...rest);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await nodeHttpResponseSendStandardResponse(res, result.response);
+    return { matched: true };
+  }
+};
+export {
+  RPCHandler,
+  nodeHttpResponseSendStandardResponse,
+  nodeHttpToStandardRequest
+};
+//# sourceMappingURL=node.js.map

package/dist/plugins.js

@@ -0,0 +1,11 @@
+import {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+} from "./chunk-OXB4YX67.js";
+export {
+  CORSPlugin,
+  CompositePlugin,
+  ResponseHeadersPlugin
+};
+//# sourceMappingURL=plugins.js.map

package/dist/src/adapters/fetch/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rpc-handler';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/fetch/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { FetchHandler, FetchHandleResult } from './types';
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/fetch/types.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
+export type FetchHandleResult = {
+    matched: true;
+    response: Response;
+} | {
+    matched: false;
+    response: undefined;
+};
+export interface FetchHandler<T extends Context> {
+    handle(request: Request, ...rest: StandardHandleRest<T>): Promise<FetchHandleResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/fetch/utils.d.ts

@@ -0,0 +1,6 @@
+import type { StandardBody, StandardRequest, StandardResponse } from '../standard';
+export declare function fetchReToStandardBody(re: Request | Response): Promise<StandardBody>;
+export declare function fetchRequestToStandardRequest(request: Request): StandardRequest;
+export declare function standardBodyToFetchBody(body: StandardBody): Blob | FormData | URLSearchParams | string | undefined;
+export declare function standardResponseToFetchResponse(response: StandardResponse): Response;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/hono/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../fetch';
+export * from './middleware';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/hono/middleware.d.ts

@@ -0,0 +1,13 @@
+import type { Context as HonoContext, MiddlewareHandler } from 'hono';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+import { type Value } from '@orpc/shared';
+export type CreateMiddlewareOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [HonoContext]>;
+} : {
+    context: Value<T, [HonoContext]>;
+});
+export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (Record<never, never> extends T ? [] : never);
+export declare function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler;
+//# sourceMappingURL=middleware.d.ts.map

package/dist/src/adapters/next/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../fetch';
+export * from './serve';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/next/serve.d.ts

@@ -0,0 +1,20 @@
+import type { NextRequest } from 'next/server';
+import type { Context } from '../../context';
+import type { FetchHandler } from '../fetch';
+import type { StandardHandleOptions } from '../standard';
+import { type Value } from '@orpc/shared';
+export type ServeOptions<T extends Context> = Omit<StandardHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: Value<T, [NextRequest]>;
+} : {
+    context: Value<T, [NextRequest]>;
+});
+export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (Record<never, never> extends T ? [] : never);
+export interface ServeResult {
+    GET(req: NextRequest): Promise<Response>;
+    POST(req: NextRequest): Promise<Response>;
+    PUT(req: NextRequest): Promise<Response>;
+    PATCH(req: NextRequest): Promise<Response>;
+    DELETE(req: NextRequest): Promise<Response>;
+}
+export declare function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult;
+//# sourceMappingURL=serve.d.ts.map

package/dist/src/adapters/node/index.d.ts

@@ -0,0 +1,4 @@
+export * from './rpc-handler';
+export * from './types';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/node/rpc-handler.d.ts

@@ -0,0 +1,10 @@
+import type { Context } from '../../context';
+import type { Router } from '../../router';
+import type { RPCHandlerOptions, StandardHandleRest } from '../standard';
+import type { NodeHttpHandler, NodeHttpHandleResult, NodeHttpRequest, NodeHttpResponse } from './types';
+export declare class RPCHandler<T extends Context> implements NodeHttpHandler<T> {
+    private readonly standardHandler;
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/node/types.d.ts

@@ -0,0 +1,21 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Http2ServerRequest, Http2ServerResponse } from 'node:http2';
+import type { Context } from '../../context';
+import type { StandardHandleRest } from '../standard';
+export type NodeHttpRequest = (IncomingMessage | Http2ServerRequest) & {
+    /**
+     * Replace `req.url` with `req.originalUrl` when `req.originalUrl` is available.
+     * This is useful for `express.js` middleware.
+     */
+    originalUrl?: string;
+};
+export type NodeHttpResponse = ServerResponse | Http2ServerResponse;
+export type NodeHttpHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+export interface NodeHttpHandler<T extends Context> {
+    handle(req: NodeHttpRequest, res: NodeHttpResponse, ...rest: StandardHandleRest<T>): Promise<NodeHttpHandleResult>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/adapters/node/utils.d.ts

@@ -0,0 +1,5 @@
+import type { StandardRequest, StandardResponse } from '../standard';
+import type { NodeHttpRequest, NodeHttpResponse } from './types';
+export declare function nodeHttpToStandardRequest(req: NodeHttpRequest, res: NodeHttpResponse): StandardRequest;
+export declare function nodeHttpResponseSendStandardResponse(res: NodeHttpResponse, standardResponse: StandardResponse): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/adapters/standard/handler.d.ts

@@ -0,0 +1,47 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { Interceptor } from '@orpc/shared';
+import type { Context } from '../../context';
+import type { Plugin } from '../../plugins';
+import type { Router } from '../../router';
+import type { StandardCodec, StandardMatcher, StandardRequest, StandardResponse } from './types';
+export type StandardHandleOptions<T extends Context> = {
+    prefix?: HTTPPath;
+} & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+export type WellStandardHandleOptions<T extends Context> = StandardHandleOptions<T> & {
+    context: T;
+};
+export type StandardHandleRest<T extends Context> = [options: StandardHandleOptions<T>] | (Record<never, never> extends T ? [] : never);
+export type StandardHandleResult = {
+    matched: true;
+    response: StandardResponse;
+} | {
+    matched: false;
+    response: undefined;
+};
+export type StandardHandlerInterceptorOptions<TContext extends Context> = WellStandardHandleOptions<TContext> & {
+    request: StandardRequest;
+};
+export interface StandardHandlerOptions<TContext extends Context> {
+    plugins?: Plugin<TContext>[];
+    /**
+     * Interceptors at the request level, helpful when you want catch errors
+     */
+    interceptors?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+    /**
+     * Interceptors at the root level, helpful when you want override the response
+     */
+    interceptorsRoot?: Interceptor<StandardHandlerInterceptorOptions<TContext>, StandardHandleResult, unknown>[];
+}
+export declare class StandardHandler<TContext extends Context> {
+    private readonly matcher;
+    private readonly codec;
+    private readonly options;
+    private readonly plugin;
+    constructor(router: Router<TContext, any>, matcher: StandardMatcher, codec: StandardCodec, options?: NoInfer<StandardHandlerOptions<TContext>>);
+    handle(request: StandardRequest, ...[options]: StandardHandleRest<TContext>): Promise<StandardHandleResult>;
+}
+//# sourceMappingURL=handler.d.ts.map

package/dist/src/adapters/standard/index.d.ts

@@ -0,0 +1,7 @@
+export * from './handler';
+export * from './rpc-codec';
+export * from './rpc-handler';
+export * from './rpc-matcher';
+export * from './rpc-serializer';
+export * from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/adapters/standard/rpc-codec.d.ts

@@ -0,0 +1,15 @@
+import type { ORPCError } from '@orpc/contract';
+import type { AnyProcedure } from '../../procedure';
+import type { StandardCodec, StandardParams, StandardRequest, StandardResponse } from './types';
+import { RPCSerializer } from './rpc-serializer';
+export interface StandardCodecOptions {
+    serializer?: RPCSerializer;
+}
+export declare class RPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(options?: StandardCodecOptions);
+    decode(request: StandardRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+//# sourceMappingURL=rpc-codec.d.ts.map

package/dist/src/adapters/standard/rpc-handler.d.ts

@@ -0,0 +1,8 @@
+import type { Context } from '../../context';
+import type { StandardHandlerOptions } from './handler';
+import type { StandardCodec, StandardMatcher } from './types';
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T> {
+    matcher?: StandardMatcher;
+    codec?: StandardCodec;
+}
+//# sourceMappingURL=rpc-handler.d.ts.map

package/dist/src/adapters/standard/rpc-matcher.d.ts

@@ -0,0 +1,10 @@
+import type { HTTPPath } from '@orpc/contract';
+import type { StandardMatcher, StandardMatchResult } from './types';
+import { type AnyRouter } from '../../router';
+export declare class RPCMatcher implements StandardMatcher {
+    private readonly tree;
+    private pendingRouters;
+    init(router: AnyRouter, path?: string[]): void;
+    match(_method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+//# sourceMappingURL=rpc-matcher.d.ts.map

package/dist/src/adapters/standard/rpc-serializer.d.ts

@@ -0,0 +1,16 @@
+import type { Segment } from '@orpc/shared';
+export type RPCSerializedJsonMeta = ['bigint' | 'date' | 'nan' | 'undefined' | 'set' | 'map' | 'regexp' | 'url', Segment[]][];
+export type RPCSerialized = {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+} | FormData | Blob;
+export type RPCSerializedFormDataMaps = Segment[][];
+export declare class RPCSerializer {
+    serialize(data: unknown): RPCSerialized;
+    deserialize(serialized: RPCSerialized): unknown;
+}
+export declare function serializeRPCJson(value: unknown, segments?: Segment[], meta?: RPCSerializedJsonMeta): {
+    json: unknown;
+    meta: RPCSerializedJsonMeta;
+};
+//# sourceMappingURL=rpc-serializer.d.ts.map

package/dist/src/adapters/standard/types.d.ts

@@ -0,0 +1,44 @@
+import type { AbortSignal, HTTPPath, ORPCError } from '@orpc/contract';
+import type { JsonValue } from '@orpc/shared';
+import type { AnyProcedure } from '../../procedure';
+import type { AnyRouter } from '../../router';
+export interface StandardHeaders {
+    [key: string]: string | string[] | undefined;
+}
+export type StandardBody = undefined | JsonValue | Blob | URLSearchParams | FormData;
+export interface StandardRequest {
+    /**
+     * Can be { request: Request } or { request: IncomingMessage, response: ServerResponse } based on the adapter.
+     */
+    raw: Record<string, unknown>;
+    method: string;
+    url: URL;
+    headers: StandardHeaders;
+    /**
+     * The body has been parsed base on the content-type header.
+     * This method can safely call multiple times (cached).
+     */
+    body(): Promise<StandardBody>;
+    signal?: AbortSignal;
+}
+export interface StandardResponse {
+    status: number;
+    headers: StandardHeaders;
+    body: StandardBody;
+}
+export type StandardParams = Record<string, string>;
+export type StandardMatchResult = {
+    path: string[];
+    procedure: AnyProcedure;
+    params?: StandardParams;
+} | undefined;
+export interface StandardMatcher {
+    init(router: AnyRouter): void;
+    match(method: string, pathname: HTTPPath): Promise<StandardMatchResult>;
+}
+export interface StandardCodec {
+    encode(output: unknown, procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+    decode(request: StandardRequest, params: StandardParams | undefined, procedure: AnyProcedure): Promise<unknown>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/builder-variants.d.ts

@@ -0,0 +1,74 @@
+import type { ContractRouter, ErrorMap, HTTPPath, MergedErrorMap, Meta, ORPCErrorConstructorMap, Route, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { BuilderDef } from './builder';
+import type { ConflictContextGuard, Context, MergedContext } from './context';
+import type { FlattenLazy } from './lazy-utils';
+import type { MapInputMiddleware, Middleware } from './middleware';
+import type { ProcedureHandler } from './procedure';
+import type { DecoratedProcedure } from './procedure-decorated';
+import type { AdaptedRouter, AdaptRouterOptions, Router } from './router';
+export interface BuilderWithMiddlewares<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'errors'<U extends ErrorMap>(errors: U): BuilderWithMiddlewares<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & BuilderWithMiddlewares<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'meta'(meta: TMeta): BuilderWithMiddlewares<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'route'(route: Route): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'input'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithInput<TInitialContext, TCurrentContext, USchema, TOutputSchema, TErrorMap, TMeta>;
+    'output'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithOutput<TInitialContext, TCurrentContext, TInputSchema, USchema, TErrorMap, TMeta>;
+    'handler'<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>;
+    'prefix'(prefix: HTTPPath): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    'tag'(...tags: string[]): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    'router'<U extends Router<TCurrentContext, ContractRouter<TMeta>>>(router: U): AdaptedRouter<U, TInitialContext, TErrorMap>;
+    'lazy'<U extends Router<TCurrentContext, ContractRouter<TMeta>>>(loader: () => Promise<{
+        default: U;
+    }>): AdaptedRouter<FlattenLazy<U>, TInitialContext, TErrorMap>;
+}
+export interface ProcedureBuilder<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'errors'<U extends ErrorMap>(errors: U): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilder<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'meta'(meta: TMeta): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'route'(route: Route): ProcedureBuilder<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'input'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithInput<TInitialContext, TCurrentContext, USchema, TOutputSchema, TErrorMap, TMeta>;
+    'output'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithOutput<TInitialContext, TCurrentContext, TInputSchema, USchema, TErrorMap, TMeta>;
+    'handler'<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>;
+}
+export interface ProcedureBuilderWithInput<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'errors'<U extends ErrorMap>(errors: U): ProcedureBuilderWithInput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilderWithInput<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'use'<UOutContext extends Context, UInput>(middleware: Middleware<TCurrentContext, UOutContext, UInput, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UInput>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilderWithInput<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'meta'(meta: TMeta): ProcedureBuilderWithInput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'route'(route: Route): ProcedureBuilderWithInput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'output'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithInputOutput<TInitialContext, TCurrentContext, TInputSchema, USchema, TErrorMap, TMeta>;
+    'handler'<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>;
+}
+export interface ProcedureBuilderWithOutput<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'errors'<U extends ErrorMap>(errors: U): ProcedureBuilderWithOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilderWithOutput<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'meta'(meta: TMeta): ProcedureBuilderWithOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'route'(route: Route): ProcedureBuilderWithOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'input'<USchema extends Schema>(schema: USchema): ProcedureBuilderWithInputOutput<TInitialContext, TCurrentContext, USchema, TOutputSchema, TErrorMap, TMeta>;
+    'handler'<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>;
+}
+export interface ProcedureBuilderWithInputOutput<TInitialContext extends Context, TCurrentContext extends Context, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': BuilderDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'errors'<U extends ErrorMap>(errors: U): ProcedureBuilderWithInputOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, SchemaOutput<TInputSchema>, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilderWithInputOutput<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'use'<UOutContext extends Context, UInput>(middleware: Middleware<TCurrentContext, UOutContext, UInput, SchemaInput<TOutputSchema>, ORPCErrorConstructorMap<TErrorMap>, TMeta>, mapInput: MapInputMiddleware<SchemaOutput<TInputSchema>, UInput>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & ProcedureBuilderWithInputOutput<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'meta'(meta: TMeta): ProcedureBuilderWithInputOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'route'(route: Route): ProcedureBuilderWithInputOutput<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    'handler'<UFuncOutput extends SchemaInput<TOutputSchema>>(handler: ProcedureHandler<TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>): DecoratedProcedure<TInitialContext, TCurrentContext, TInputSchema, TOutputSchema, UFuncOutput, TErrorMap, TMeta>;
+}
+export interface RouterBuilder<TInitialContext extends Context, TCurrentContext extends Context, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    '~orpc': AdaptRouterOptions<TErrorMap>;
+    'errors'<U extends ErrorMap>(errors: U): RouterBuilder<TInitialContext, TCurrentContext, MergedErrorMap<TErrorMap, U>, TMeta>;
+    'use'<UOutContext extends Context>(middleware: Middleware<TCurrentContext, UOutContext, unknown, unknown, ORPCErrorConstructorMap<TErrorMap>, TMeta>): ConflictContextGuard<MergedContext<TCurrentContext, UOutContext>> & RouterBuilder<TInitialContext, MergedContext<TCurrentContext, UOutContext>, TErrorMap, TMeta>;
+    'prefix'(prefix: HTTPPath): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    'tag'(...tags: string[]): RouterBuilder<TInitialContext, TCurrentContext, TErrorMap, TMeta>;
+    'router'<U extends Router<TCurrentContext, ContractRouter<TMeta>>>(router: U): AdaptedRouter<U, TInitialContext, TErrorMap>;
+    'lazy'<U extends Router<TCurrentContext, ContractRouter<TMeta>>>(loader: () => Promise<{
+        default: U;
+    }>): AdaptedRouter<FlattenLazy<U>, TInitialContext, TErrorMap>;
+}
+//# sourceMappingURL=builder-variants.d.ts.map