@orpc/server 0.28.0 → 0.30.0

package/dist/index.js

@@ -9,15 +9,16 @@ import {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   unlazy
-} from "./chunk-DNG2IB3R.js";
+} from "./chunk-SA7HGGVY.js";
 
 // src/builder.ts
 import { ContractProcedure } from "@orpc/contract";
 
 // src/implementer-chainable.ts
 import { isContractProcedure } from "@orpc/contract";
-import { createCallableObject } from "@orpc/shared";
+import { createCallableObject as createCallableObject2 } from "@orpc/shared";
 
 // src/middleware-decorated.ts
 function decorateMiddleware(middleware) {
@@ -44,58 +45,78 @@ function decorateMiddleware(middleware) {
 
 // src/procedure-decorated.ts
 import { DecoratedContractProcedure } from "@orpc/contract";
-function decorateProcedure(procedure) {
-  const caller = createProcedureClient({
-    procedure,
-    context: void 0
-  });
-  const decorated = caller;
-  decorated["~type"] = procedure["~type"];
-  decorated["~orpc"] = procedure["~orpc"];
-  decorated.prefix = (prefix) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).prefix(prefix)
-    }));
-  };
-  decorated.route = (route) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).route(route)
-    }));
-  };
-  decorated.use = (middleware, mapInput) => {
+import { createCallableObject } from "@orpc/shared";
+var DecoratedProcedure = class _DecoratedProcedure extends Procedure {
+  static decorate(procedure) {
+    if (procedure instanceof _DecoratedProcedure) {
+      return procedure;
+    }
+    return new _DecoratedProcedure(procedure["~orpc"]);
+  }
+  prefix(prefix) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).prefix(prefix)
+    });
+  }
+  route(route) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).route(route)
+    });
+  }
+  errors(errors) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).errors(errors)
+    });
+  }
+  use(middleware, mapInput) {
     const middleware_ = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares: [...procedure["~orpc"].middlewares ?? [], middleware_]
-    }));
-  };
-  decorated.unshiftTag = (...tags) => {
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      contract: DecoratedContractProcedure.decorate(procedure["~orpc"].contract).unshiftTag(...tags)
-    }));
-  };
-  decorated.unshiftMiddleware = (...middlewares) => {
-    if (procedure["~orpc"].middlewares?.length) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      postMiddlewares: [...this["~orpc"].postMiddlewares, middleware_]
+    });
+  }
+  unshiftTag(...tags) {
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      contract: DecoratedContractProcedure.decorate(this["~orpc"].contract).unshiftTag(...tags)
+    });
+  }
+  unshiftMiddleware(...middlewares) {
+    const castedMiddlewares = middlewares;
+    if (this["~orpc"].preMiddlewares.length) {
       let min = 0;
-      for (let i = 0; i < procedure["~orpc"].middlewares.length; i++) {
-        const index = middlewares.indexOf(procedure["~orpc"].middlewares[i], min);
+      for (let i = 0; i < this["~orpc"].preMiddlewares.length; i++) {
+        const index = castedMiddlewares.indexOf(this["~orpc"].preMiddlewares[i], min);
         if (index === -1) {
-          middlewares.push(...procedure["~orpc"].middlewares.slice(i));
+          castedMiddlewares.push(...this["~orpc"].preMiddlewares.slice(i));
           break;
         }
         min = index + 1;
       }
     }
-    return decorateProcedure(new Procedure({
-      ...procedure["~orpc"],
-      middlewares
-    }));
-  };
-  return decorated;
-}
+    return new _DecoratedProcedure({
+      ...this["~orpc"],
+      preMiddlewares: castedMiddlewares
+    });
+  }
+  /**
+   * Make this procedure callable (works like a function while still being a procedure).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  callable(...rest) {
+    return createCallableObject(this, createProcedureClient(this, ...rest));
+  }
+  /**
+   * Make this procedure compatible with server action (the same as .callable, but the type is compatible with server action).
+   * **Note**: this only takes effect when this method is called at the end of the chain.
+   */
+  actionable(...rest) {
+    return this.callable(...rest);
+  }
+};
 
 // src/procedure-implementer.ts
 var ProcedureImplementer = class _ProcedureImplementer {
@@ -108,15 +129,16 @@ var ProcedureImplementer = class _ProcedureImplementer {
     const mappedMiddleware = mapInput ? decorateMiddleware(middleware).mapInput(mapInput) : middleware;
     return new _ProcedureImplementer({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], mappedMiddleware]
+      postMiddlewares: [...this["~orpc"].postMiddlewares, mappedMiddleware]
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
+    return new DecoratedProcedure({
+      postMiddlewares: this["~orpc"].postMiddlewares,
+      preMiddlewares: this["~orpc"].preMiddlewares,
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -154,31 +176,10 @@ function getLazyRouterPrefix(obj) {
   return obj[LAZY_ROUTER_PREFIX_SYMBOL];
 }
 
-// src/lazy-utils.ts
-function createLazyProcedureFormAnyLazy(lazied) {
-  const lazyProcedure = lazy(async () => {
-    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
-    if (!isProcedure(maybeProcedure)) {
-      throw new Error(`
-            Expected a lazy<procedure> but got lazy<unknown>.
-            This should be caught by TypeScript compilation.
-            Please report this issue if this makes you feel uncomfortable.
-        `);
-    }
-    return { default: maybeProcedure };
-  });
-  return lazyProcedure;
-}
-
 // src/lazy-decorated.ts
 function decorateLazy(lazied) {
   const flattenLazy = flatLazy(lazied);
-  const procedureProcedureClient = createProcedureClient({
-    procedure: createLazyProcedureFormAnyLazy(flattenLazy),
-    context: void 0
-  });
-  Object.assign(procedureProcedureClient, flattenLazy);
-  const recursive = new Proxy(procedureProcedureClient, {
+  const recursive = new Proxy(flattenLazy, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
@@ -215,10 +216,19 @@ var RouterBuilder = class _RouterBuilder {
       tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
+  errors(errors) {
+    return new _RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   use(middleware) {
     return new _RouterBuilder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
     });
   }
   router(router) {
@@ -245,7 +255,7 @@ function adapt(item, options) {
     return adaptedLazy;
   }
   if (isProcedure(item)) {
-    let decorated = decorateProcedure(item);
+    let decorated = DecoratedProcedure.decorate(item);
     if (options.tags?.length) {
       decorated = decorated.unshiftTag(...options.tags);
     }
@@ -255,6 +265,9 @@ function adapt(item, options) {
     if (options.middlewares?.length) {
       decorated = decorated.unshiftMiddleware(...options.middlewares);
     }
+    if (Object.keys(options.errorMap).length) {
+      decorated = decorated.errors(options.errorMap);
+    }
     return decorated;
   }
   const adapted = {};
@@ -278,23 +291,30 @@ var RouterImplementer = class _RouterImplementer {
     });
   }
   router(router) {
-    const adapted = new RouterBuilder(this["~orpc"]).router(router);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).router(router);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
   lazy(loader) {
-    const adapted = new RouterBuilder(this["~orpc"]).lazy(loader);
+    const adapted = new RouterBuilder({
+      ...this["~orpc"],
+      errorMap: {}
+    }).lazy(loader);
     const contracted = setRouterContract(adapted, this["~orpc"].contract);
     return contracted;
   }
 };
 
 // src/implementer-chainable.ts
-function createChainableImplementer(contract, middlewares) {
+function createChainableImplementer(contract, middlewares = []) {
   if (isContractProcedure(contract)) {
     const implementer = new ProcedureImplementer({
       contract,
-      middlewares
+      preMiddlewares: middlewares,
+      postMiddlewares: []
     });
     return implementer;
   }
@@ -313,7 +333,7 @@ function createChainableImplementer(contract, middlewares) {
       if (!next) {
         return method.bind(routerImplementer);
       }
-      return createCallableObject(next, method.bind(routerImplementer));
+      return createCallableObject2(next, method.bind(routerImplementer));
     }
   });
   return merged;
@@ -357,20 +377,23 @@ var ProcedureBuilder = class _ProcedureBuilder {
     if (!mapInput) {
       return new ProcedureImplementer({
         contract: this["~orpc"].contract,
-        middlewares: this["~orpc"].middlewares
+        preMiddlewares: this["~orpc"].middlewares,
+        postMiddlewares: []
       }).use(middleware);
     }
     return new ProcedureImplementer({
       contract: this["~orpc"].contract,
-      middlewares: this["~orpc"].middlewares
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: []
     }).use(middleware, mapInput);
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
+    return new DecoratedProcedure({
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: [],
       contract: this["~orpc"].contract,
       handler
-    }));
+    });
   }
 };
 
@@ -381,15 +404,29 @@ var Builder = class _Builder {
   constructor(def) {
     this["~orpc"] = def;
   }
+  // TODO: separate it
   context() {
-    return new _Builder({});
+    return new _Builder({
+      middlewares: [],
+      errorMap: {}
+    });
   }
   use(middleware) {
     return new _Builder({
       ...this["~orpc"],
-      middlewares: [...this["~orpc"].middlewares ?? [], middleware]
+      middlewares: [...this["~orpc"].middlewares, middleware]
+    });
+  }
+  errors(errors) {
+    return new _Builder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
     });
   }
+  // TODO: not allow define middleware after has context, or anything else
   middleware(middleware) {
     return decorateMiddleware(middleware);
   }
@@ -400,7 +437,7 @@ var Builder = class _Builder {
         route,
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
@@ -411,7 +448,7 @@ var Builder = class _Builder {
         OutputSchema: void 0,
         InputSchema: schema,
         inputExample: example,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
@@ -422,40 +459,33 @@ var Builder = class _Builder {
         InputSchema: void 0,
         OutputSchema: schema,
         outputExample: example,
-        errorMap: void 0
-      })
-    });
-  }
-  errors(errors) {
-    return new ProcedureBuilder({
-      middlewares: this["~orpc"].middlewares,
-      contract: new ContractProcedure({
-        InputSchema: void 0,
-        OutputSchema: void 0,
-        errorMap: errors
+        errorMap: this["~orpc"].errorMap
       })
     });
   }
   handler(handler) {
-    return decorateProcedure(new Procedure({
-      middlewares: this["~orpc"].middlewares,
+    return new DecoratedProcedure({
+      preMiddlewares: this["~orpc"].middlewares,
+      postMiddlewares: [],
       contract: new ContractProcedure({
         InputSchema: void 0,
         OutputSchema: void 0,
-        errorMap: void 0
+        errorMap: this["~orpc"].errorMap
       }),
       handler
-    }));
+    });
   }
   prefix(prefix) {
     return new RouterBuilder({
       middlewares: this["~orpc"].middlewares,
+      errorMap: this["~orpc"].errorMap,
       prefix
     });
   }
   tag(...tags) {
     return new RouterBuilder({
       middlewares: this["~orpc"].middlewares,
+      errorMap: this["~orpc"].errorMap,
       tags
     });
   }
@@ -470,36 +500,47 @@ var Builder = class _Builder {
   }
 };
 
+// src/procedure-utils.ts
+function call(procedure, input, ...rest) {
+  return createProcedureClient(procedure, ...rest)(input);
+}
+
+// src/lazy-utils.ts
+function createLazyProcedureFormAnyLazy(lazied) {
+  const lazyProcedure = lazy(async () => {
+    const { default: maybeProcedure } = await unlazy(flatLazy(lazied));
+    if (!isProcedure(maybeProcedure)) {
+      throw new Error(`
+            Expected a lazy<procedure> but got lazy<unknown>.
+            This should be caught by TypeScript compilation.
+            Please report this issue if this makes you feel uncomfortable.
+        `);
+    }
+    return { default: maybeProcedure };
+  });
+  return lazyProcedure;
+}
+
 // src/router-client.ts
-function createRouterClient(options) {
-  if (isProcedure(options.router)) {
-    const caller = createProcedureClient({
-      ...options,
-      procedure: options.router,
-      context: options.context,
-      path: options.path
-    });
+function createRouterClient(router, ...rest) {
+  if (isProcedure(router)) {
+    const caller = createProcedureClient(router, ...rest);
     return caller;
   }
-  const procedureCaller = isLazy(options.router) ? createProcedureClient({
-    ...options,
-    procedure: createLazyProcedureFormAnyLazy(options.router),
-    context: options.context,
-    path: options.path
-  }) : {};
+  const procedureCaller = isLazy(router) ? createProcedureClient(createLazyProcedureFormAnyLazy(router), ...rest) : {};
   const recursive = new Proxy(procedureCaller, {
     get(target, key) {
       if (typeof key !== "string") {
         return Reflect.get(target, key);
       }
-      const next = getRouterChild(options.router, key);
+      const next = getRouterChild(router, key);
       if (!next) {
         return Reflect.get(target, key);
       }
-      return createRouterClient({
+      const [options] = rest;
+      return createRouterClient(next, {
         ...options,
-        router: next,
-        path: [...options.path ?? [], key]
+        path: [...options?.path ?? [], key]
       });
     }
   });
@@ -508,9 +549,13 @@ function createRouterClient(options) {
 
 // src/index.ts
 import { configGlobal, fallbackToGlobalConfig, isDefinedError, ORPCError, safe } from "@orpc/contract";
-var os = new Builder({});
+var os = new Builder({
+  middlewares: [],
+  errorMap: {}
+});
 export {
   Builder,
+  DecoratedProcedure,
   LAZY_LOADER_SYMBOL,
   ORPCError,
   Procedure,
@@ -518,6 +563,7 @@ export {
   ProcedureImplementer,
   RouterBuilder,
   RouterImplementer,
+  call,
   configGlobal,
   createChainableImplementer,
   createORPCErrorConstructorMap,
@@ -525,7 +571,6 @@ export {
   createRouterClient,
   decorateLazy,
   decorateMiddleware,
-  decorateProcedure,
   deepSetLazyRouterPrefix,
   fallbackToGlobalConfig,
   flatLazy,
@@ -537,6 +582,7 @@ export {
   isProcedure,
   lazy,
   mergeContext,
+  middlewareOutputFn,
   os,
   safe,
   setRouterContract,

package/dist/next.js

@@ -1,11 +1,11 @@
 import "./chunk-WUOGVGWG.js";
 import {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 
 // src/adapters/next/serve.ts
 import { value } from "@orpc/shared";
@@ -27,9 +27,9 @@ function serve(handler, ...[options]) {
   };
 }
 export {
-  ORPCHandler,
   ORPCPayloadCodec,
   ORPCProcedureMatcher,
+  RPCHandler,
   super_json_exports as SuperJSON,
   serve
 };

package/dist/node.js

@@ -1,7 +1,7 @@
 import {
-  ORPCHandler
-} from "./chunk-V3I7RIRY.js";
-import "./chunk-DNG2IB3R.js";
+  RPCHandler
+} from "./chunk-2HRHHZJD.js";
+import "./chunk-SA7HGGVY.js";
 
 // src/adapters/node/request-listener.ts
 function createRequest(req, res) {
@@ -61,10 +61,10 @@ async function sendResponse(res, response) {
 }
 
 // src/adapters/node/orpc-handler.ts
-var ORPCHandler2 = class {
+var RPCHandler2 = class {
   orpcFetchHandler;
   constructor(router, options) {
-    this.orpcFetchHandler = new ORPCHandler(router, options);
+    this.orpcFetchHandler = new RPCHandler(router, options);
   }
   async handle(req, res, ...[options]) {
     const request = createRequest(req, res);
@@ -79,7 +79,7 @@ var ORPCHandler2 = class {
   }
 };
 export {
-  ORPCHandler2 as ORPCHandler,
+  RPCHandler2 as RPCHandler,
   createHeaders,
   createRequest,
   sendResponse

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

@@ -4,17 +4,17 @@ import type { Context } from '../../types';
 import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types';
 import { type PublicORPCPayloadCodec } from './orpc-payload-codec';
 import { type PublicORPCProcedureMatcher } from './orpc-procedure-matcher';
-export type ORPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
+export type RPCHandlerOptions<T extends Context> = Hooks<Request, FetchHandleResult, T, {
     signal?: AbortSignal;
 }> & {
     procedureMatcher?: PublicORPCProcedureMatcher;
     payloadCodec?: PublicORPCPayloadCodec;
 };
-export declare class ORPCHandler<T extends Context> implements FetchHandler<T> {
+export declare class RPCHandler<T extends Context> implements FetchHandler<T> {
     private readonly options?;
     private readonly procedureMatcher;
     private readonly payloadCodec;
-    constructor(router: Router<T, any>, options?: NoInfer<ORPCHandlerOptions<T>> | undefined);
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>> | undefined);
     handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult>;
 }
 //# sourceMappingURL=orpc-handler.d.ts.map

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

@@ -1,12 +1,12 @@
 import type { ServerResponse } from 'node:http';
 import type { Router } from '../../router';
 import type { Context } from '../../types';
-import type { ORPCHandlerOptions } from '../fetch/orpc-handler';
+import type { RPCHandlerOptions } from '../fetch/orpc-handler';
 import type { RequestHandler, RequestHandleRest, RequestHandleResult } from './types';
 import { type ExpressableIncomingMessage } from './request-listener';
-export declare class ORPCHandler<T extends Context> implements RequestHandler<T> {
+export declare class RPCHandler<T extends Context> implements RequestHandler<T> {
     private readonly orpcFetchHandler;
-    constructor(router: Router<T, any>, options?: NoInfer<ORPCHandlerOptions<T>>);
+    constructor(router: Router<T, any>, options?: NoInfer<RPCHandlerOptions<T>>);
     handle(req: ExpressableIncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult>;
 }
 //# sourceMappingURL=orpc-handler.d.ts.map

package/dist/src/builder.d.ts

@@ -1,36 +1,38 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractRouter, ErrorMap, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput } from '@orpc/contract';
+import type { ContractRouter, ErrorMap, ErrorMapGuard, ErrorMapSuggestions, HTTPPath, RouteOptions, Schema, SchemaInput, SchemaOutput, StrictErrorMap } from '@orpc/contract';
+import type { ORPCErrorConstructorMap } from './error';
 import type { FlattenLazy } from './lazy';
 import type { Middleware } from './middleware';
 import type { DecoratedMiddleware } from './middleware-decorated';
+import type { ProcedureHandler } from './procedure';
 import type { Router } from './router';
 import type { AdaptedRouter } from './router-builder';
 import type { Context, MergeContext, WELL_CONTEXT } from './types';
 import { type ChainableImplementer } from './implementer-chainable';
-import { type ProcedureHandler } from './procedure';
 import { ProcedureBuilder } from './procedure-builder';
-import { type DecoratedProcedure } from './procedure-decorated';
+import { DecoratedProcedure } from './procedure-decorated';
 import { RouterBuilder } from './router-builder';
-export interface BuilderDef<TContext extends Context, TExtraContext extends Context> {
-    middlewares?: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<string, unknown>>[];
+export interface BuilderDef<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> {
+    middlewares: Middleware<MergeContext<TContext, TExtraContext>, Partial<TExtraContext> | undefined, unknown, any, Record<never, never>>[];
+    errorMap: TErrorMap;
 }
-export declare class Builder<TContext extends Context, TExtraContext extends Context> {
+export declare class Builder<TContext extends Context, TExtraContext extends Context, TErrorMap extends ErrorMap> {
     '~type': "Builder";
-    '~orpc': BuilderDef<TContext, TExtraContext>;
-    constructor(def: BuilderDef<TContext, TExtraContext>);
-    context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined>;
-    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, Record<string, unknown>>): Builder<TContext, MergeContext<TExtraContext, U>>;
-    middleware<UExtraContext extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<string, unknown>>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<string, unknown>>;
-    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, undefined>;
-    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined, undefined>;
-    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema, undefined>;
-    errors<UErrorMap extends ErrorMap>(errors: UErrorMap): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, UErrorMap>;
-    handler<UFuncOutput = undefined>(handler: ProcedureHandler<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput, undefined>;
-    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext>;
-    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext>;
-    router<U extends Router<MergeContext<TContext, TExtraContext>, any>>(router: U): AdaptedRouter<TContext, U>;
-    lazy<U extends Router<MergeContext<TContext, TExtraContext>, any>>(loader: () => Promise<{
+    '~orpc': BuilderDef<TContext, TExtraContext, TErrorMap>;
+    constructor(def: BuilderDef<TContext, TExtraContext, TErrorMap>);
+    context<UContext extends Context = WELL_CONTEXT>(): Builder<UContext, undefined, Record<never, never>>;
+    use<U extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined>(middleware: Middleware<MergeContext<TContext, TExtraContext>, U, unknown, unknown, ORPCErrorConstructorMap<TErrorMap>>): Builder<TContext, MergeContext<TExtraContext, U>, TErrorMap>;
+    errors<U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): Builder<TContext, TExtraContext, TErrorMap & U>;
+    middleware<UExtraContext extends Context & Partial<MergeContext<TContext, TExtraContext>> | undefined = undefined, TInput = unknown, TOutput = any>(middleware: Middleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<never, never>>): DecoratedMiddleware<MergeContext<TContext, TExtraContext>, UExtraContext, TInput, TOutput, Record<never, never>>;
+    route(route: RouteOptions): ProcedureBuilder<TContext, TExtraContext, undefined, undefined, TErrorMap>;
+    input<USchema extends Schema>(schema: USchema, example?: SchemaInput<USchema>): ProcedureBuilder<TContext, TExtraContext, USchema, undefined, TErrorMap>;
+    output<USchema extends Schema>(schema: USchema, example?: SchemaOutput<USchema>): ProcedureBuilder<TContext, TExtraContext, undefined, USchema, TErrorMap>;
+    handler<UFuncOutput = undefined>(handler: ProcedureHandler<TContext, TExtraContext, undefined, undefined, UFuncOutput, TErrorMap>): DecoratedProcedure<TContext, TExtraContext, undefined, undefined, UFuncOutput, TErrorMap>;
+    prefix(prefix: HTTPPath): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    tag(...tags: string[]): RouterBuilder<TContext, TExtraContext, TErrorMap>;
+    router<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(router: U): AdaptedRouter<TContext, U, TErrorMap>;
+    lazy<U extends Router<MergeContext<TContext, TExtraContext>, ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>>(loader: () => Promise<{
         default: U;
-    }>): AdaptedRouter<TContext, FlattenLazy<U>>;
-    contract<U extends ANY_CONTRACT_PROCEDURE | ContractRouter>(contract: U): ChainableImplementer<TContext, TExtraContext, U>;
+    }>): AdaptedRouter<TContext, FlattenLazy<U>, TErrorMap>;
+    contract<U extends ContractRouter<any>>(contract: U): ChainableImplementer<TContext, TExtraContext, U>;
 }
 //# sourceMappingURL=builder.d.ts.map