@orpc/contract 0.0.0-next.eb37cbe → 0.0.0-next.ed15210

package/dist/index.js

@@ -6,6 +6,9 @@ var ContractProcedure = class {
     if (def.route?.successStatus && (def.route.successStatus < 200 || def.route?.successStatus > 299)) {
       throw new Error("[ContractProcedure] The successStatus must be between 200 and 299");
     }
+    if (Object.values(def.errorMap).some((val) => val && val.status && (val.status < 400 || val.status > 599))) {
+      throw new Error("[ContractProcedure] The error status code must be in the 400-599 range.");
+    }
     this["~orpc"] = def;
   }
 };
@@ -13,7 +16,36 @@ function isContractProcedure(item) {
   if (item instanceof ContractProcedure) {
     return true;
   }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"];
+  return (typeof item === "object" || typeof item === "function") && item !== null && "~type" in item && item["~type"] === "ContractProcedure" && "~orpc" in item && typeof item["~orpc"] === "object" && item["~orpc"] !== null && "InputSchema" in item["~orpc"] && "OutputSchema" in item["~orpc"] && "errorMap" in item["~orpc"] && "route" in item["~orpc"];
+}
+
+// src/route.ts
+function mergeRoute(a, b) {
+  return {
+    ...a,
+    ...b
+  };
+}
+function prefixRoute(route, prefix) {
+  if (!route.path) {
+    return route;
+  }
+  return {
+    ...route,
+    path: `${prefix}${route.path}`
+  };
+}
+function unshiftTagRoute(route, tags) {
+  return {
+    ...route,
+    tags: [...tags, ...route.tags ?? []]
+  };
+}
+function mergePrefix(a, b) {
+  return a ? `${a}${b}` : b;
+}
+function mergeTags(a, b) {
+  return a ? [...a, ...b] : b;
 }
 
 // src/procedure-decorated.ts
@@ -24,44 +56,116 @@ var DecoratedContractProcedure = class _DecoratedContractProcedure extends Contr
     }
     return new _DecoratedContractProcedure(procedure["~orpc"]);
   }
+  errors(errors) {
+    return new _DecoratedContractProcedure({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   route(route) {
     return new _DecoratedContractProcedure({
       ...this["~orpc"],
-      route
+      route: mergeRoute(this["~orpc"].route, route)
     });
   }
   prefix(prefix) {
     return new _DecoratedContractProcedure({
       ...this["~orpc"],
-      ...this["~orpc"].route?.path ? {
-        route: {
-          ...this["~orpc"].route,
-          path: `${prefix}${this["~orpc"].route.path}`
-        }
-      } : void 0
+      route: prefixRoute(this["~orpc"].route, prefix)
     });
   }
   unshiftTag(...tags) {
     return new _DecoratedContractProcedure({
       ...this["~orpc"],
-      route: {
-        ...this["~orpc"].route,
-        tags: [
-          ...tags,
-          ...this["~orpc"].route?.tags?.filter((tag) => !tags.includes(tag)) ?? []
-        ]
-      }
+      route: unshiftTagRoute(this["~orpc"].route, tags)
     });
   }
+};
+
+// src/procedure-builder-with-input.ts
+var ContractProcedureBuilderWithInput = class _ContractProcedureBuilderWithInput extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilderWithInput(decorated["~orpc"]);
+  }
+  output(schema, example) {
+    return new DecoratedContractProcedure({
+      ...this["~orpc"],
+      OutputSchema: schema,
+      outputExample: example
+    });
+  }
+};
+
+// src/procedure-builder-with-output.ts
+var ContractProcedureBuilderWithOutput = class _ContractProcedureBuilderWithOutput extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilderWithOutput(decorated["~orpc"]);
+  }
   input(schema, example) {
-    return new _DecoratedContractProcedure({
+    return new DecoratedContractProcedure({
+      ...this["~orpc"],
+      InputSchema: schema,
+      inputExample: example
+    });
+  }
+};
+
+// src/procedure-builder.ts
+var ContractProcedureBuilder = class _ContractProcedureBuilder extends ContractProcedure {
+  errors(errors) {
+    const decorated = DecoratedContractProcedure.decorate(this).errors(errors);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  route(route) {
+    const decorated = DecoratedContractProcedure.decorate(this).route(route);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  prefix(prefix) {
+    const decorated = DecoratedContractProcedure.decorate(this).prefix(prefix);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  unshiftTag(...tags) {
+    const decorated = DecoratedContractProcedure.decorate(this).unshiftTag(...tags);
+    return new _ContractProcedureBuilder(decorated["~orpc"]);
+  }
+  input(schema, example) {
+    return new ContractProcedureBuilderWithInput({
       ...this["~orpc"],
       InputSchema: schema,
       inputExample: example
     });
   }
   output(schema, example) {
-    return new _DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
       ...this["~orpc"],
       OutputSchema: schema,
       outputExample: example
@@ -79,13 +183,22 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
   prefix(prefix) {
     return new _ContractRouterBuilder({
       ...this["~orpc"],
-      prefix: `${this["~orpc"].prefix ?? ""}${prefix}`
+      prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
   tag(...tags) {
     return new _ContractRouterBuilder({
       ...this["~orpc"],
-      tags: [...this["~orpc"].tags ?? [], ...tags]
+      tags: mergeTags(this["~orpc"].tags, tags)
+    });
+  }
+  errors(errors) {
+    return new _ContractRouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
     });
   }
   router(router) {
@@ -97,6 +210,7 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
       if (this["~orpc"].prefix) {
         decorated = decorated.prefix(this["~orpc"].prefix);
       }
+      decorated = decorated.errors(this["~orpc"].errorMap);
       return decorated;
     }
     const adapted = {};
@@ -108,51 +222,306 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
 };
 
 // src/builder.ts
-var ContractBuilder = class {
-  prefix(prefix) {
-    return new ContractRouterBuilder({
-      prefix
+var ContractBuilder = class _ContractBuilder extends ContractProcedure {
+  constructor(def) {
+    super(def);
+    this["~orpc"].config = def.config;
+  }
+  config(config) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      config: {
+        ...this["~orpc"].config,
+        ...config
+      }
     });
   }
-  tag(...tags) {
-    return new ContractRouterBuilder({
-      tags
+  errors(errors) {
+    return new _ContractBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
     });
   }
   route(route) {
-    return new DecoratedContractProcedure({
-      route,
+    return new ContractProcedureBuilder({
+      route: mergeRoute(this["~orpc"].route, route),
       InputSchema: void 0,
-      OutputSchema: void 0
+      OutputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
     });
   }
   input(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithInput({
+      route: this["~orpc"].route,
       InputSchema: schema,
       inputExample: example,
-      OutputSchema: void 0
+      OutputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
     });
   }
   output(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
+      route: this["~orpc"].route,
       OutputSchema: schema,
       outputExample: example,
-      InputSchema: void 0
+      InputSchema: void 0,
+      errorMap: this["~orpc"].errorMap
+    });
+  }
+  prefix(prefix) {
+    return new ContractRouterBuilder({
+      prefix,
+      errorMap: this["~orpc"].errorMap,
+      tags: void 0
+    });
+  }
+  tag(...tags) {
+    return new ContractRouterBuilder({
+      tags,
+      errorMap: this["~orpc"].errorMap,
+      prefix: void 0
     });
   }
   router(router) {
-    return router;
+    return new ContractRouterBuilder({
+      errorMap: this["~orpc"].errorMap,
+      prefix: void 0,
+      tags: void 0
+    }).router(router);
+  }
+};
+
+// src/error-orpc.ts
+import { isPlainObject } from "@orpc/shared";
+var COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+var ORPCError = class extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(options) {
+    if (options.status && (options.status < 400 || options.status >= 600)) {
+      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+    }
+    const message = fallbackORPCErrorMessage(options.code, options.message);
+    super(message, options);
+    this.code = options.code;
+    this.status = fallbackORPCErrorStatus(options.code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+  static isValidJSON(json) {
+    return isPlainObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
 };
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+async function validateORPCError(map, error) {
+  const { code, status, message, data, cause, defined } = error;
+  const config = map?.[error.code];
+  if (!config || fallbackORPCErrorStatus(error.code, config.status) !== error.status) {
+    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+  }
+  if (!config.data) {
+    return defined ? error : new ORPCError({ defined: true, code, status, message, data, cause });
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    return defined ? new ORPCError({ defined: false, code, status, message, data, cause }) : error;
+  }
+  return new ORPCError({
+    defined: true,
+    code,
+    status,
+    message,
+    data: validated.value,
+    cause
+  });
+}
+
+// src/client-utils.ts
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return [output, void 0, false];
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return [void 0, error, true];
+    }
+    return [void 0, error, false];
+  }
+}
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  defaultMethod: "POST",
+  defaultSuccessStatus: 200,
+  defaultSuccessDescription: "OK",
+  defaultInputStructure: "compact",
+  defaultOutputStructure: "compact",
+  defaultInitialRoute: {}
+};
+function fallbackContractConfig(key, value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG[key];
+  }
+  return value;
+}
+
+// src/error.ts
+var ValidationError = class extends Error {
+  issues;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+  }
+};
+
+// src/schema-utils.ts
+function type(...[map]) {
+  return {
+    "~standard": {
+      vendor: "custom",
+      version: 1,
+      async validate(value) {
+        if (map) {
+          return { value: await map(value) };
+        }
+        return { value };
+      }
+    }
+  };
+}
 
 // src/index.ts
-var oc = new ContractBuilder();
+var oc = new ContractBuilder({
+  config: {},
+  route: {},
+  errorMap: {},
+  InputSchema: void 0,
+  OutputSchema: void 0
+});
 export {
+  COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
+  ContractProcedureBuilder,
+  ContractProcedureBuilderWithInput,
+  ContractProcedureBuilderWithOutput,
   ContractRouterBuilder,
   DecoratedContractProcedure,
+  ORPCError,
+  ValidationError,
+  fallbackContractConfig,
+  fallbackORPCErrorMessage,
+  fallbackORPCErrorStatus,
   isContractProcedure,
-  oc
+  isDefinedError,
+  mergePrefix,
+  mergeRoute,
+  mergeTags,
+  oc,
+  prefixRoute,
+  safe,
+  type,
+  unshiftTagRoute,
+  validateORPCError
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,14 +1,32 @@
-import type { RouteOptions } from './procedure';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { ContractProcedureDef } from './procedure';
+import type { HTTPPath, MergeRoute, Route, StrictRoute } from './route';
 import type { ContractRouter } from './router';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { DecoratedContractProcedure } from './procedure-decorated';
+import type { AdaptedContractRouter } from './router-builder';
+import type { Schema, SchemaInput, SchemaOutput } from './types';
+import { ContractProcedure } from './procedure';
+import { ContractProcedureBuilder } from './procedure-builder';
+import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
+import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
 import { ContractRouterBuilder } from './router-builder';
-export declare class ContractBuilder {
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    route(route: RouteOptions): DecoratedContractProcedure<undefined, undefined>;
-    input<U extends Schema = undefined>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined>;
-    output<U extends Schema = undefined>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U>;
-    router<T extends ContractRouter>(router: T): T;
+export interface ContractBuilderConfig {
+    initialRoute?: Route;
+}
+export type MergeContractBuilderConfig<A extends ContractBuilderConfig, B extends ContractBuilderConfig> = Omit<A, keyof B> & B;
+export type GetInitialRoute<T extends ContractBuilderConfig> = T['initialRoute'] extends Route ? T['initialRoute'] : Record<never, never>;
+export interface ContractBuilderDef<TConfig extends ContractBuilderConfig, TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>> {
+    config: TConfig;
+}
+export declare class ContractBuilder<TConfig extends ContractBuilderConfig, TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap, GetInitialRoute<TConfig>> {
+    '~orpc': ContractBuilderDef<TConfig, TErrorMap>;
+    constructor(def: ContractBuilderDef<TConfig, TErrorMap>);
+    config<const U extends ContractBuilderConfig>(config: U): ContractBuilder<MergeContractBuilderConfig<TConfig, U>, TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<TConfig, StrictErrorMap<U> & TErrorMap>;
+    route<const U extends Route>(route: U): ContractProcedureBuilder<TErrorMap, MergeRoute<StrictRoute<GetInitialRoute<TConfig>>, U>>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap, StrictRoute<GetInitialRoute<TConfig>>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractRouterBuilder<TErrorMap, U, undefined>;
+    tag<U extends string[]>(...tags: U): ContractRouterBuilder<TErrorMap, undefined, U>;
+    router<T extends ContractRouter<ErrorMap & Partial<TErrorMap>>>(router: T): AdaptedContractRouter<T, TErrorMap, undefined, undefined>;
 }
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/client-utils.d.ts

@@ -0,0 +1,5 @@
+import type { ClientPromiseResult } from './client';
+import { type ORPCError } from './error-orpc';
+export type SafeResult<TOutput, TError extends Error> = [output: TOutput, error: undefined, isDefinedError: false] | [output: undefined, error: TError, isDefinedError: false] | [output: undefined, error: Extract<TError, ORPCError<any, any>>, isDefinedError: true];
+export declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+//# sourceMappingURL=client-utils.d.ts.map

package/dist/src/client.d.ts

@@ -0,0 +1,19 @@
+import type { AbortSignal } from './types';
+export type ClientOptions<TClientContext> = {
+    signal?: AbortSignal;
+} & (undefined extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+export type ClientRest<TClientContext, TInput> = [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never);
+export type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
+    __typeError?: TError;
+};
+export interface Client<TClientContext, TInput, TOutput, TError extends Error> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+export type NestedClient<TClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+//# sourceMappingURL=client.d.ts.map

package/dist/src/config.d.ts

@@ -0,0 +1,11 @@
+import type { HTTPMethod, InputStructure, Route } from './route';
+export interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: InputStructure;
+    defaultInitialRoute: Route;
+}
+export declare function fallbackContractConfig<T extends keyof ContractConfig>(key: T, value: ContractConfig[T] | undefined): ContractConfig[T];
+//# sourceMappingURL=config.d.ts.map

package/dist/src/error-map.d.ts

@@ -0,0 +1,58 @@
+import type { CommonORPCErrorCode } from './error-orpc';
+import type { Schema } from './types';
+export type ErrorMapItem<TDataSchema extends Schema> = {
+    /**
+     *
+     * @default 500
+     */
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+};
+export interface ErrorMap {
+    [k: string]: ErrorMapItem<Schema>;
+}
+/**
+ * const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions
+ *
+ * Purpose:
+ * - Helps `U` suggest `CommonORPCErrorCode` to the user when typing.
+ *
+ * Why not replace `ErrorMap` with `ErrorMapSuggestions`?
+ * - `ErrorMapSuggestions` has a drawback: it allows `undefined` values for items.
+ * - `ErrorMapGuard<TErrorMap>` uses `Partial`, which can introduce `undefined` values.
+ *
+ * This could lead to unintended behavior where `undefined` values override `TErrorMap`,
+ * potentially resulting in a `never` type after merging.
+ *
+ * Recommendation:
+ * - Use `ErrorMapSuggestions` to assist users in typing correctly but do not replace `ErrorMap`.
+ * - Ensure `ErrorMapGuard<TErrorMap>` is adjusted to prevent `undefined` values.
+ */
+export type ErrorMapSuggestions = {
+    [key in CommonORPCErrorCode | (string & {})]?: ErrorMapItem<Schema>;
+};
+/**
+ * `U` extends `ErrorMap` & `ErrorMapGuard<TErrorMap>`
+ *
+ * `ErrorMapGuard` is a utility type that ensures `U` cannot redefine the structure of `TErrorMap`.
+ * It achieves this by setting each key in `TErrorMap` to `never`, effectively preventing any redefinition.
+ *
+ * Why not just use `Partial<TErrorMap>`?
+ * - Allowing users to redefine existing error map items would require using `StrictErrorMap`.
+ * - However, I prefer not to use `StrictErrorMap` frequently, due to perceived performance concerns,
+ *   though this has not been benchmarked and is based on personal preference.
+ *
+ */
+export type ErrorMapGuard<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]?: never;
+};
+/**
+ * Since `undefined` has a specific meaning (it use default value),
+ * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
+ */
+export type StrictErrorMap<T extends ErrorMap> = {
+    [K in keyof T]: T[K] & Partial<Record<Exclude<keyof ErrorMapItem<any>, keyof T[K]>, undefined>>;
+};
+//# sourceMappingURL=error-map.d.ts.map

package/dist/src/error-orpc.d.ts

@@ -0,0 +1,109 @@
+import type { ErrorMap, ErrorMapItem } from './error-map';
+import type { SchemaOutput } from './types';
+export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+export declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+export type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+export type ORPCErrorOptions<TCode extends string, TData> = ErrorOptions & {
+    defined?: boolean;
+    code: TCode;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+export declare function fallbackORPCErrorStatus(code: CommonORPCErrorCode | (string & {}), status: number | undefined): number;
+export declare function fallbackORPCErrorMessage(code: CommonORPCErrorCode | (string & {}), message: string | undefined): string;
+export declare class ORPCError<TCode extends CommonORPCErrorCode | (string & {}), TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(options: ORPCErrorOptions<TCode, TData>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<string, unknown>;
+}
+export type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+//# sourceMappingURL=error-orpc.d.ts.map

package/dist/src/error.d.ts

@@ -0,0 +1,13 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { ErrorMap } from './error-map';
+import type { ORPCErrorFromErrorMap } from './error-orpc';
+export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+export interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly StandardSchemaV1.Issue[];
+}
+export declare class ValidationError extends Error {
+    readonly issues: readonly StandardSchemaV1.Issue[];
+    constructor(options: ValidationErrorOptions);
+}
+//# sourceMappingURL=error.d.ts.map

package/dist/src/index.d.ts

@@ -1,10 +1,23 @@
 /** unnoq */
 import { ContractBuilder } from './builder';
 export * from './builder';
+export * from './client';
+export * from './client-utils';
+export * from './config';
+export * from './error';
+export * from './error-map';
+export * from './error-orpc';
 export * from './procedure';
+export * from './procedure-builder';
+export * from './procedure-builder-with-input';
+export * from './procedure-builder-with-output';
+export * from './procedure-client';
 export * from './procedure-decorated';
+export * from './route';
 export * from './router';
 export * from './router-builder';
+export * from './router-client';
+export * from './schema-utils';
 export * from './types';
-export declare const oc: ContractBuilder;
+export declare const oc: ContractBuilder<{}, {}>;
 //# sourceMappingURL=index.d.ts.map

package/dist/src/procedure-builder-with-input.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaOutput } from './types';
+import { ContractProcedure } from './procedure';
+import { DecoratedContractProcedure } from './procedure-decorated';
+/**
+ * `ContractProcedureBuilderWithInput` is a branch of `ContractProcedureBuilder` which it has input schema.
+ *
+ * Why?
+ * - prevents override input schema after .input
+ */
+export declare class ContractProcedureBuilderWithInput<TInputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<TInputSchema, undefined, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder-with-input.d.ts.map

package/dist/src/procedure-builder-with-output.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaInput } from './types';
+import { ContractProcedure } from './procedure';
+import { DecoratedContractProcedure } from './procedure-decorated';
+/**
+ * `ContractProcedureBuilderWithOutput` is a branch of `ContractProcedureBuilder` which it has output schema.
+ *
+ * Why?
+ * - prevents override output schema after .output
+ */
+export declare class ContractProcedureBuilderWithOutput<TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<undefined, TOutputSchema, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithOutput<TOutputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder-with-output.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { HTTPPath, MergeRoute, PrefixRoute, Route, UnshiftTagRoute } from './route';
+import type { Schema, SchemaInput, SchemaOutput } from './types';
+import { ContractProcedure } from './procedure';
+import { ContractProcedureBuilderWithInput } from './procedure-builder-with-input';
+import { ContractProcedureBuilderWithOutput } from './procedure-builder-with-output';
+export declare class ContractProcedureBuilder<TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<undefined, undefined, TErrorMap, TRoute> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilder<StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): ContractProcedureBuilder<TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): ContractProcedureBuilder<TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): ContractProcedureBuilder<TErrorMap, UnshiftTagRoute<TRoute, U>>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap, TRoute>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap, TRoute>;
+}
+//# sourceMappingURL=procedure-builder.d.ts.map

package/dist/src/procedure-client.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from './client';
+import type { ErrorFromErrorMap } from './error';
+import type { ErrorMap } from './error-map';
+import type { Schema, SchemaInput, SchemaOutput } from './types';
+export type ContractProcedureClient<TClientContext, TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> = Client<TClientContext, SchemaInput<TInputSchema>, SchemaOutput<TOutputSchema>, ErrorFromErrorMap<TErrorMap>>;
+//# sourceMappingURL=procedure-client.d.ts.map

package/dist/src/procedure-decorated.d.ts

@@ -1,12 +1,12 @@
-import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { Schema } from './types';
 import { ContractProcedure } from './procedure';
-export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> extends ContractProcedure<TInputSchema, TOutputSchema> {
-    static decorate<UInputSchema extends Schema = undefined, UOutputSchema extends Schema = undefined>(procedure: ContractProcedure<UInputSchema, UOutputSchema>): DecoratedContractProcedure<UInputSchema, UOutputSchema>;
-    route(route: RouteOptions): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    prefix(prefix: HTTPPath): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    unshiftTag(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema>;
-    input<U extends Schema = undefined>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema>;
-    output<U extends Schema = undefined>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U>;
+import { type HTTPPath, type MergeRoute, type PrefixRoute, type Route, type UnshiftTagRoute } from './route';
+export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap, TRoute> {
+    static decorate<UInputSchema extends Schema, UOutputSchema extends Schema, UErrorMap extends ErrorMap, URoute extends Route>(procedure: ContractProcedure<UInputSchema, UOutputSchema, UErrorMap, URoute>): DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrorMap, URoute>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, StrictErrorMap<U> & TErrorMap, TRoute>;
+    route<const U extends Route>(route: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, MergeRoute<TRoute, U>>;
+    prefix<U extends HTTPPath>(prefix: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, PrefixRoute<TRoute, U>>;
+    unshiftTag<U extends string[]>(...tags: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap, UnshiftTagRoute<TRoute, U>>;
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

package/dist/src/procedure.d.ts

@@ -1,26 +1,20 @@
-import type { HTTPMethod, HTTPPath, Schema, SchemaOutput } from './types';
-export interface RouteOptions {
-    method?: HTTPMethod;
-    path?: HTTPPath;
-    summary?: string;
-    description?: string;
-    deprecated?: boolean;
-    tags?: readonly string[];
-    successStatus?: number;
-}
-export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema> {
-    route?: RouteOptions;
+import type { ErrorMap } from './error-map';
+import type { Route } from './route';
+import type { Schema, SchemaOutput } from './types';
+export interface ContractProcedureDef<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> {
+    route: TRoute;
     InputSchema: TInputSchema;
     inputExample?: SchemaOutput<TInputSchema>;
     OutputSchema: TOutputSchema;
     outputExample?: SchemaOutput<TOutputSchema>;
+    errorMap: TErrorMap;
 }
-export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema> {
+export declare class ContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap, TRoute extends Route> {
     '~type': "ContractProcedure";
-    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema>;
-    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema>);
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TRoute>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TRoute>);
 }
-export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any>;
-export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema>;
+export type ANY_CONTRACT_PROCEDURE = ContractProcedure<any, any, any, any>;
+export type WELL_CONTRACT_PROCEDURE = ContractProcedure<Schema, Schema, ErrorMap, Route>;
 export declare function isContractProcedure(item: unknown): item is ANY_CONTRACT_PROCEDURE;
 //# sourceMappingURL=procedure.d.ts.map

package/dist/src/route.d.ts

@@ -0,0 +1,88 @@
+export type HTTPPath = `/${string}`;
+export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+export type InputStructure = 'compact' | 'detailed';
+export type OutputStructure = 'compact' | 'detailed';
+export interface Route {
+    method?: HTTPMethod;
+    path?: HTTPPath;
+    summary?: string;
+    description?: string;
+    deprecated?: boolean;
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     *
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *
+     * @default 'OK'
+     */
+    successDescription?: string;
+    /**
+     * Determines how the input should be structured based on `params`, `query`, `headers`, and `body`.
+     *
+     * @option 'compact'
+     * Combines `params` and either `query` or `body` (depending on the HTTP method) into a single object.
+     *
+     * @option 'detailed'
+     * Keeps each part of the request (`params`, `query`, `headers`, and `body`) as separate fields in the input object.
+     *
+     * Example:
+     * ```ts
+     * const input = {
+     *   params: { id: 1 },
+     *   query: { search: 'hello' },
+     *   headers: { 'Content-Type': 'application/json' },
+     *   body: { name: 'John' },
+     * }
+     * ```
+     *
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * Includes only the body data, encoded directly in the response.
+     *
+     * @option 'detailed'
+     * Separates the output into `headers` and `body` fields.
+     * - `headers`: Custom headers to merge with the response headers.
+     * - `body`: The response data.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+}
+/**
+ * Since `undefined` has a specific meaning (it use default value),
+ * we ensure all additional properties in each item of the ErrorMap are explicitly set to `undefined`.
+ */
+export type StrictRoute<T extends Route> = T & Partial<Record<Exclude<keyof Route, keyof T>, undefined>>;
+export type MergeRoute<A extends Route, B extends Route> = Omit<A, keyof B> & B;
+export declare function mergeRoute<A extends Route, B extends Route>(a: A, b: B): MergeRoute<A, B>;
+export type PrefixRoute<TRoute extends Route, TPrefix extends HTTPPath> = TRoute['path'] extends HTTPPath ? Omit<TRoute, 'path'> & {
+    path: TPrefix extends HTTPPath ? `${TPrefix}${TRoute['path']}` : TRoute['path'];
+} : TRoute;
+export declare function prefixRoute<TRoute extends Route, TPrefix extends HTTPPath>(route: TRoute, prefix: TPrefix): PrefixRoute<TRoute, TPrefix>;
+export type UnshiftTagRoute<TRoute extends Route, TTags extends readonly string[]> = Omit<TRoute, 'tags'> & {
+    tags: TRoute['tags'] extends string[] ? [...TTags, ...TRoute['tags']] : TTags;
+};
+export declare function unshiftTagRoute<TRoute extends Route, TTags extends readonly string[]>(route: TRoute, tags: TTags): UnshiftTagRoute<TRoute, TTags>;
+export type MergePrefix<A extends HTTPPath | undefined, B extends HTTPPath> = A extends HTTPPath ? `${A}${B}` : B;
+export declare function mergePrefix<A extends HTTPPath | undefined, B extends HTTPPath>(a: A, b: B): MergePrefix<A, B>;
+export type MergeTags<A extends readonly string[] | undefined, B extends readonly string[]> = A extends readonly string[] ? [...A, ...B] : B;
+export declare function mergeTags<A extends readonly string[] | undefined, B extends readonly string[]>(a: A, b: B): MergeTags<A, B>;
+//# sourceMappingURL=route.d.ts.map

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

@@ -1,20 +1,24 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
 import type { ContractProcedure } from './procedure';
 import type { ContractRouter } from './router';
-import type { HTTPPath } from './types';
 import { DecoratedContractProcedure } from './procedure-decorated';
-export type AdaptedContractRouter<TContract extends ContractRouter> = {
-    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema> ? DecoratedContractProcedure<UInputSchema, UOutputSchema> : TContract[K] extends ContractRouter ? AdaptedContractRouter<TContract[K]> : never;
+import { type HTTPPath, type MergePrefix, type MergeTags, type PrefixRoute, type Route, type UnshiftTagRoute } from './route';
+export type AdaptRoute<TRoute extends Route, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> = TPrefix extends HTTPPath ? PrefixRoute<TTags extends readonly string[] ? UnshiftTagRoute<TRoute, TTags> : TRoute, TPrefix> : TTags extends readonly string[] ? UnshiftTagRoute<TRoute, TTags> : TRoute;
+export type AdaptedContractRouter<TContract extends ContractRouter<any>, TErrorMapExtra extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors, infer URoute> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors & TErrorMapExtra, AdaptRoute<URoute, TPrefix, TTags>> : TContract[K] extends ContractRouter<any> ? AdaptedContractRouter<TContract[K], TErrorMapExtra, TPrefix, TTags> : never;
 };
-export interface ContractRouterBuilderDef {
-    prefix?: HTTPPath;
-    tags?: string[];
+export interface ContractRouterBuilderDef<TErrorMap extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> {
+    errorMap: TErrorMap;
+    prefix: TPrefix;
+    tags: TTags;
 }
-export declare class ContractRouterBuilder {
+export declare class ContractRouterBuilder<TErrorMap extends ErrorMap, TPrefix extends HTTPPath | undefined, TTags extends readonly string[] | undefined> {
     '~type': "ContractProcedure";
-    '~orpc': ContractRouterBuilderDef;
-    constructor(def: ContractRouterBuilderDef);
-    prefix(prefix: HTTPPath): ContractRouterBuilder;
-    tag(...tags: string[]): ContractRouterBuilder;
-    router<T extends ContractRouter>(router: T): AdaptedContractRouter<T>;
+    '~orpc': ContractRouterBuilderDef<TErrorMap, TPrefix, TTags>;
+    constructor(def: ContractRouterBuilderDef<TErrorMap, TPrefix, TTags>);
+    prefix<U extends HTTPPath>(prefix: U): ContractRouterBuilder<TErrorMap, MergePrefix<TPrefix, U>, TTags>;
+    tag<U extends string[]>(...tags: U): ContractRouterBuilder<TErrorMap, TPrefix, MergeTags<TTags, U>>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractRouterBuilder<StrictErrorMap<U> & TErrorMap, TPrefix, TTags>;
+    router<T extends ContractRouter<ErrorMap & Partial<TErrorMap>>>(router: T): AdaptedContractRouter<T, TErrorMap, TPrefix, TTags>;
 }
 //# sourceMappingURL=router-builder.d.ts.map

package/dist/src/router-client.d.ts

@@ -0,0 +1,7 @@
+import type { ContractProcedure } from './procedure';
+import type { ContractProcedureClient } from './procedure-client';
+import type { ContractRouter } from './router';
+export type ContractRouterClient<TRouter extends ContractRouter<any>, TClientContext> = TRouter extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrorMap, any> ? ContractProcedureClient<TClientContext, UInputSchema, UOutputSchema, UErrorMap> : {
+    [K in keyof TRouter]: TRouter[K] extends ContractRouter<any> ? ContractRouterClient<TRouter[K], TClientContext> : never;
+};
+//# sourceMappingURL=router-client.d.ts.map

package/dist/src/router.d.ts

@@ -1,12 +1,13 @@
-import type { ANY_CONTRACT_PROCEDURE, ContractProcedure } from './procedure';
+import type { ErrorMap } from './error-map';
+import type { ContractProcedure } from './procedure';
 import type { SchemaInput, SchemaOutput } from './types';
-export type ContractRouter = ANY_CONTRACT_PROCEDURE | {
-    [k: string]: ContractRouter;
+export type ContractRouter<T extends ErrorMap> = ContractProcedure<any, any, T, any> | {
+    [k: string]: ContractRouter<T>;
 };
-export type InferContractRouterInputs<T extends ContractRouter> = T extends ContractProcedure<infer UInputSchema, any> ? SchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter ? InferContractRouterInputs<T[K]> : never;
+export type InferContractRouterInputs<T extends ContractRouter<any>> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? SchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterInputs<T[K]> : never;
 };
-export type InferContractRouterOutputs<T extends ContractRouter> = T extends ContractProcedure<any, infer UOutputSchema> ? SchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends ContractRouter ? InferContractRouterOutputs<T[K]> : never;
+export type InferContractRouterOutputs<T extends ContractRouter<any>> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? SchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends ContractRouter<any> ? InferContractRouterOutputs<T[K]> : never;
 };
 //# sourceMappingURL=router.d.ts.map

package/dist/src/schema-utils.d.ts

@@ -0,0 +1,5 @@
+import type { IsEqual, Promisable } from '@orpc/shared';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+export type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+export declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): StandardSchemaV1<TInput, TOutput>;
+//# sourceMappingURL=schema-utils.d.ts.map

package/dist/src/types.d.ts

@@ -1,7 +1,7 @@
+import type { FindGlobalInstanceType } from '@orpc/shared';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-export type HTTPPath = `/${string}`;
-export type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 export type Schema = StandardSchemaV1 | undefined;
 export type SchemaInput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TSchema> : TFallback;
 export type SchemaOutput<TSchema extends Schema, TFallback = unknown> = TSchema extends undefined ? TFallback : TSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TSchema> : TFallback;
+export type AbortSignal = FindGlobalInstanceType<'AbortSignal'>;
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.eb37cbe",
+  "version": "0.0.0-next.ed15210",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -30,7 +30,7 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "1.0.0-beta.4",
-    "@orpc/shared": "0.0.0-next.eb37cbe"
+    "@orpc/shared": "0.0.0-next.ed15210"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",