@orpc/contract 0.0.0-next.9b3a030 → 0.0.0-next.a2e4a58

package/dist/index.js

@@ -27,6 +27,15 @@ 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"],
@@ -59,24 +68,92 @@ var DecoratedContractProcedure = class _DecoratedContractProcedure extends Contr
       }
     });
   }
+};
+
+// 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
     });
   }
-  output(schema, example) {
-    return new _DecoratedContractProcedure({
+};
+
+// 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"],
-      OutputSchema: schema,
-      outputExample: example
+      InputSchema: schema,
+      inputExample: example
     });
   }
-  errors(errorMap) {
-    return new _DecoratedContractProcedure({
+  output(schema, example) {
+    return new ContractProcedureBuilderWithOutput({
       ...this["~orpc"],
-      errorMap
+      OutputSchema: schema,
+      outputExample: example
     });
   }
 };
@@ -100,6 +177,15 @@ var ContractRouterBuilder = class _ContractRouterBuilder {
       tags: [...this["~orpc"].tags ?? [], ...tags]
     });
   }
+  errors(errors) {
+    return new _ContractRouterBuilder({
+      ...this["~orpc"],
+      errorMap: {
+        ...this["~orpc"].errorMap,
+        ...errors
+      }
+    });
+  }
   router(router) {
     if (isContractProcedure(router)) {
       let decorated = DecoratedContractProcedure.decorate(router);
@@ -109,6 +195,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 = {};
@@ -120,50 +207,73 @@ 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);
+  }
+  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: {
+        ...this["~orpc"].config.initialRoute,
+        ...route
+      },
       InputSchema: void 0,
       OutputSchema: void 0,
-      errorMap: void 0
+      errorMap: this["~orpc"].errorMap
     });
   }
   input(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithInput({
+      route: this["~orpc"].config.initialRoute,
       InputSchema: schema,
       inputExample: example,
       OutputSchema: void 0,
-      errorMap: void 0
+      errorMap: this["~orpc"].errorMap
     });
   }
   output(schema, example) {
-    return new DecoratedContractProcedure({
+    return new ContractProcedureBuilderWithOutput({
+      route: this["~orpc"].config.initialRoute,
       OutputSchema: schema,
       outputExample: example,
       InputSchema: void 0,
-      errorMap: void 0
+      errorMap: this["~orpc"].errorMap
     });
   }
-  errors(errorMap) {
-    return new DecoratedContractProcedure({
-      InputSchema: void 0,
-      OutputSchema: void 0,
-      errorMap
+  prefix(prefix) {
+    return new ContractRouterBuilder({
+      prefix,
+      errorMap: this["~orpc"].errorMap
+    });
+  }
+  tag(...tags) {
+    return new ContractRouterBuilder({
+      tags,
+      errorMap: this["~orpc"].errorMap
     });
   }
   router(router) {
-    return router;
+    return new ContractRouterBuilder({
+      errorMap: this["~orpc"].errorMap
+    }).router(router);
   }
 };
 
@@ -330,20 +440,9 @@ var DEFAULT_CONFIG = {
   defaultInputStructure: "compact",
   defaultOutputStructure: "compact"
 };
-var GLOBAL_CONFIG_REF = { value: DEFAULT_CONFIG };
-function configGlobal(config) {
-  if (config.defaultSuccessStatus !== void 0 && (config.defaultSuccessStatus < 200 || config.defaultSuccessStatus > 299)) {
-    throw new Error("[configGlobal] The defaultSuccessStatus must be between 200 and 299");
-  }
-  GLOBAL_CONFIG_REF.value = config;
-}
-function fallbackToGlobalConfig(key, value) {
+function fallbackContractConfig(key, value) {
   if (value === void 0) {
-    const fallback = GLOBAL_CONFIG_REF.value[key];
-    if (fallback === void 0) {
-      return DEFAULT_CONFIG[key];
-    }
-    return fallback;
+    return DEFAULT_CONFIG[key];
   }
   return value;
 }
@@ -357,24 +456,48 @@ var ValidationError = class extends Error {
   }
 };
 
+// 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({
+  errorMap: {},
+  InputSchema: void 0,
+  OutputSchema: void 0,
+  config: {}
+});
 export {
   COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
+  ContractProcedureBuilder,
+  ContractProcedureBuilderWithInput,
+  ContractProcedureBuilderWithOutput,
   ContractRouterBuilder,
   DecoratedContractProcedure,
   ORPCError,
   ValidationError,
-  configGlobal,
+  fallbackContractConfig,
   fallbackORPCErrorMessage,
   fallbackORPCErrorStatus,
-  fallbackToGlobalConfig,
   isContractProcedure,
   isDefinedError,
   oc,
   safe,
+  type,
   validateORPCError
 };
 //# sourceMappingURL=index.js.map

package/dist/src/builder.d.ts

@@ -1,16 +1,29 @@
-import type { ErrorMap } from './error-map';
-import type { RouteOptions } from './procedure';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions, StrictErrorMap } from './error-map';
+import type { ContractProcedureDef, RouteOptions } from './procedure';
 import type { ContractRouter } from './router';
+import type { AdaptedContractRouter } from './router-builder';
 import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
-import { DecoratedContractProcedure } from './procedure-decorated';
+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, undefined>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, undefined, undefined>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<undefined, U, undefined>;
-    errors<const U extends ErrorMap>(errorMap: U): DecoratedContractProcedure<undefined, undefined, U>;
-    router<T extends ContractRouter>(router: T): T;
+export interface ContractBuilderConfig {
+    initialRoute?: RouteOptions;
+}
+export interface ContractBuilderDef<TErrorMap extends ErrorMap> extends ContractProcedureDef<undefined, undefined, TErrorMap> {
+    config: ContractBuilderConfig;
+}
+export declare class ContractBuilder<TErrorMap extends ErrorMap> extends ContractProcedure<undefined, undefined, TErrorMap> {
+    '~orpc': ContractBuilderDef<TErrorMap>;
+    constructor(def: ContractBuilderDef<TErrorMap>);
+    config(config: ContractBuilderConfig): ContractBuilder<TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractBuilder<U & TErrorMap>;
+    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
+    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
 }
 //# sourceMappingURL=builder.d.ts.map

package/dist/src/client.d.ts

@@ -6,11 +6,12 @@ export type ClientOptions<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> {
-    (...opts: [input: TInput, options: ClientOptions<TClientContext>] | (undefined extends TInput & TClientContext ? [] : never) | (undefined extends TClientContext ? [input: TInput] : never)): ClientPromiseResult<TOutput, TError>;
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
 }
 export type NestedClient<TClientContext> = Client<TClientContext, any, any, any> | {
     [k: string]: NestedClient<TClientContext>;

package/dist/src/config.d.ts

@@ -1,36 +1,10 @@
 import type { HTTPMethod, InputStructure } from './types';
-export interface ORPCConfig {
-    /**
-     * @default 'POST'
-     */
-    defaultMethod?: HTTPMethod;
-    /**
-     *
-     * @default 200
-     */
-    defaultSuccessStatus?: number;
-    /**
-     *
-     * @default 'OK'
-     */
-    defaultSuccessDescription?: string;
-    /**
-     *
-     * @default 'compact'
-     */
-    defaultInputStructure?: InputStructure;
-    /**
-     *
-     * @default 'compact'
-     */
-    defaultOutputStructure?: InputStructure;
+export interface ContractConfig {
+    defaultMethod: HTTPMethod;
+    defaultSuccessStatus: number;
+    defaultSuccessDescription: string;
+    defaultInputStructure: InputStructure;
+    defaultOutputStructure: InputStructure;
 }
-/**
- * Set the global configuration, this configuration can effect entire project
- */
-export declare function configGlobal(config: ORPCConfig): void;
-/**
- * Fallback the value to the global config if it is undefined
- */
-export declare function fallbackToGlobalConfig<T extends keyof ORPCConfig>(key: T, value: ORPCConfig[T]): Exclude<ORPCConfig[T], undefined>;
+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

@@ -3,14 +3,56 @@ import type { Schema } from './types';
 export type ErrorMapItem<TDataSchema extends Schema> = {
     /**
      *
-     * @default 200
+     * @default 500
      */
     status?: number;
     message?: string;
     description?: string;
     data?: TDataSchema;
 };
-export type ErrorMap = undefined | {
+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/index.d.ts

@@ -8,9 +8,15 @@ 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 './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<Record<never, never>>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,19 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
+import type { RouteOptions } from './procedure';
+import type { HTTPPath, 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> extends ContractProcedure<TInputSchema, undefined, TErrorMap> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap & U>;
+    route(route: RouteOptions): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
+    prefix(prefix: HTTPPath): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
+    unshiftTag(...tags: string[]): ContractProcedureBuilderWithInput<TInputSchema, TErrorMap>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap>;
+}
+//# 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 } from './error-map';
+import type { RouteOptions } from './procedure';
+import type { HTTPPath, 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> extends ContractProcedure<undefined, TOutputSchema, TErrorMap> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap & U>;
+    route(route: RouteOptions): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
+    prefix(prefix: HTTPPath): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
+    unshiftTag(...tags: string[]): ContractProcedureBuilderWithOutput<TOutputSchema, TErrorMap>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap>;
+}
+//# sourceMappingURL=procedure-builder-with-output.d.ts.map

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

@@ -0,0 +1,15 @@
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
+import type { RouteOptions } from './procedure';
+import type { HTTPPath, 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> extends ContractProcedure<undefined, undefined, TErrorMap> {
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractProcedureBuilder<TErrorMap & U>;
+    route(route: RouteOptions): ContractProcedureBuilder<TErrorMap>;
+    prefix(prefix: HTTPPath): ContractProcedureBuilder<TErrorMap>;
+    unshiftTag(...tags: string[]): ContractProcedureBuilder<TErrorMap>;
+    input<U extends Schema>(schema: U, example?: SchemaInput<U>): ContractProcedureBuilderWithInput<U, TErrorMap>;
+    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): ContractProcedureBuilderWithOutput<U, TErrorMap>;
+}
+//# 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,14 +1,12 @@
-import type { ErrorMap } from './error-map';
+import type { ErrorMap, ErrorMapGuard, ErrorMapSuggestions } from './error-map';
 import type { RouteOptions } from './procedure';
-import type { HTTPPath, Schema, SchemaInput, SchemaOutput } from './types';
+import type { HTTPPath, Schema } from './types';
 import { ContractProcedure } from './procedure';
 export declare class DecoratedContractProcedure<TInputSchema extends Schema, TOutputSchema extends Schema, TErrorMap extends ErrorMap> extends ContractProcedure<TInputSchema, TOutputSchema, TErrorMap> {
     static decorate<UInputSchema extends Schema, UOutputSchema extends Schema, TErrorMap extends ErrorMap>(procedure: ContractProcedure<UInputSchema, UOutputSchema, TErrorMap>): DecoratedContractProcedure<UInputSchema, UOutputSchema, TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap & U>;
     route(route: RouteOptions): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     prefix(prefix: HTTPPath): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
     unshiftTag(...tags: string[]): DecoratedContractProcedure<TInputSchema, TOutputSchema, TErrorMap>;
-    input<U extends Schema>(schema: U, example?: SchemaInput<U>): DecoratedContractProcedure<U, TOutputSchema, TErrorMap>;
-    output<U extends Schema>(schema: U, example?: SchemaOutput<U>): DecoratedContractProcedure<TInputSchema, U, TErrorMap>;
-    errors<const U extends ErrorMap>(errorMap: U): DecoratedContractProcedure<TInputSchema, TOutputSchema, U>;
 }
 //# sourceMappingURL=procedure-decorated.d.ts.map

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

@@ -1,20 +1,23 @@
+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, infer UErrors> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors> : TContract[K] extends ContractRouter ? AdaptedContractRouter<TContract[K]> : never;
+export type AdaptedContractRouter<TContract extends ContractRouter<any>, TErrorMapExtra extends ErrorMap> = {
+    [K in keyof TContract]: TContract[K] extends ContractProcedure<infer UInputSchema, infer UOutputSchema, infer UErrors> ? DecoratedContractProcedure<UInputSchema, UOutputSchema, UErrors & TErrorMapExtra> : TContract[K] extends ContractRouter<any> ? AdaptedContractRouter<TContract[K], TErrorMapExtra> : never;
 };
-export interface ContractRouterBuilderDef {
+export interface ContractRouterBuilderDef<TErrorMap extends ErrorMap> {
     prefix?: HTTPPath;
     tags?: string[];
+    errorMap: TErrorMap;
 }
-export declare class ContractRouterBuilder {
+export declare class ContractRouterBuilder<TErrorMap extends ErrorMap> {
     '~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>;
+    constructor(def: ContractRouterBuilderDef<TErrorMap>);
+    prefix(prefix: HTTPPath): ContractRouterBuilder<TErrorMap>;
+    tag(...tags: string[]): ContractRouterBuilder<TErrorMap>;
+    errors<const U extends ErrorMap & ErrorMapGuard<TErrorMap> & ErrorMapSuggestions>(errors: U): ContractRouterBuilder<U & TErrorMap>;
+    router<T extends ContractRouter<ErrorMap & Partial<StrictErrorMap<TErrorMap>>>>(router: T): AdaptedContractRouter<T, TErrorMap>;
 }
 //# 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> ? 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> | {
+    [k: string]: ContractRouter<T>;
 };
-export type InferContractRouterInputs<T extends ContractRouter> = T extends ContractProcedure<infer UInputSchema, any, 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> ? 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, any> ? 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> ? 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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.0.0-next.9b3a030",
+  "version": "0.0.0-next.a2e4a58",
   "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.9b3a030"
+    "@orpc/shared": "0.0.0-next.a2e4a58"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",