@orpc/contract 0.0.0-next.b0f324e → 0.0.0-next.b12bcdb

package/dist/index.mjs

@@ -1,41 +1,13 @@
+import { i as isContractProcedure, C as ContractProcedure, m as mergeErrorMap, V as ValidationError } from './shared/contract.D_dZrO__.mjs';
+export { v as validateORPCError } from './shared/contract.D_dZrO__.mjs';
 import { mapEventIterator, ORPCError } from '@orpc/client';
 export { ORPCError } from '@orpc/client';
-import { isAsyncIteratorObject } from '@orpc/shared';
-
-class ValidationError extends Error {
-  issues;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
-  }
-}
-function mergeErrorMap(errorMap1, errorMap2) {
-  return { ...errorMap1, ...errorMap2 };
-}
+import { isAsyncIteratorObject, get, isTypescriptObject, isPropertyKey } from '@orpc/shared';
 
 function mergeMeta(meta1, meta2) {
   return { ...meta1, ...meta2 };
 }
 
-class ContractProcedure {
-  "~orpc";
-  constructor(def) {
-    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;
-  }
-}
-function isContractProcedure(item) {
-  if (item instanceof ContractProcedure) {
-    return true;
-  }
-  return (typeof item === "object" || typeof item === "function") && item !== null && "~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"] && "meta" in item["~orpc"];
-}
-
 function mergeRoute(a, b) {
   return { ...a, ...b };
 }
@@ -60,31 +32,62 @@ function mergePrefix(a, b) {
 function mergeTags(a, b) {
   return a ? [...a, ...b] : b;
 }
-function adaptRoute(route, options) {
+function enhanceRoute(route, options) {
   let router = route;
   if (options.prefix) {
     router = prefixRoute(router, options.prefix);
   }
-  if (options.tags) {
+  if (options.tags?.length) {
     router = unshiftTagRoute(router, options.tags);
   }
   return router;
 }
 
-function adaptContractRouter(contract, options) {
-  if (isContractProcedure(contract)) {
-    const adapted2 = new ContractProcedure({
-      ...contract["~orpc"],
-      errorMap: mergeErrorMap(options.errorMap, contract["~orpc"].errorMap),
-      route: adaptRoute(contract["~orpc"].route, options)
+function getContractRouter(router, path) {
+  let current = router;
+  for (let i = 0; i < path.length; i++) {
+    const segment = path[i];
+    if (!current) {
+      return void 0;
+    }
+    if (isContractProcedure(current)) {
+      return void 0;
+    }
+    current = current[segment];
+  }
+  return current;
+}
+function enhanceContractRouter(router, options) {
+  if (isContractProcedure(router)) {
+    const enhanced2 = new ContractProcedure({
+      ...router["~orpc"],
+      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
+      route: enhanceRoute(router["~orpc"].route, options)
     });
-    return adapted2;
+    return enhanced2;
   }
-  const adapted = {};
-  for (const key in contract) {
-    adapted[key] = adaptContractRouter(contract[key], options);
+  const enhanced = {};
+  for (const key in router) {
+    enhanced[key] = enhanceContractRouter(router[key], options);
   }
-  return adapted;
+  return enhanced;
+}
+function minifyContractRouter(router) {
+  if (isContractProcedure(router)) {
+    const procedure = {
+      "~orpc": {
+        errorMap: {},
+        meta: router["~orpc"].meta,
+        route: router["~orpc"].route
+      }
+    };
+    return procedure;
+  }
+  const json = {};
+  for (const key in router) {
+    json[key] = minifyContractRouter(router[key]);
+  }
+  return json;
 }
 
 class ContractBuilder extends ContractProcedure {
@@ -94,7 +97,9 @@ class ContractBuilder extends ContractProcedure {
     this["~orpc"].tags = def.tags;
   }
   /**
-   * Reset initial meta
+   * Sets or overrides the initial meta.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
    */
   $meta(initialMeta) {
     return new ContractBuilder({
@@ -103,7 +108,11 @@ class ContractBuilder extends ContractProcedure {
     });
   }
   /**
-   * Reset initial route
+   * Sets or overrides the initial route.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
   $route(initialRoute) {
     return new ContractBuilder({
@@ -111,56 +120,103 @@ class ContractBuilder extends ContractProcedure {
       route: initialRoute
     });
   }
+  /**
+   * Adds type-safe custom errors to the contract.
+   * The provided errors are spared-merged with any existing errors in the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
+   */
   errors(errors) {
     return new ContractBuilder({
       ...this["~orpc"],
       errorMap: mergeErrorMap(this["~orpc"].errorMap, errors)
     });
   }
+  /**
+   * Sets or updates the metadata for the contract.
+   * The provided metadata is spared-merged with any existing metadata in the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
+   */
   meta(meta) {
     return new ContractBuilder({
       ...this["~orpc"],
       meta: mergeMeta(this["~orpc"].meta, meta)
     });
   }
+  /**
+   * Sets or updates the route definition for the contract.
+   * The provided route is spared-merged with any existing route in the contract.
+   * This option is typically relevant when integrating with OpenAPI.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+   */
   route(route) {
     return new ContractBuilder({
       ...this["~orpc"],
       route: mergeRoute(this["~orpc"].route, route)
     });
   }
+  /**
+   * Defines the input validation schema for the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Input Validation Docs}
+   */
   input(schema) {
     return new ContractBuilder({
       ...this["~orpc"],
       inputSchema: schema
     });
   }
+  /**
+   * Defines the output validation schema for the contract.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
+   */
   output(schema) {
     return new ContractBuilder({
       ...this["~orpc"],
       outputSchema: schema
     });
   }
+  /**
+   * Prefixes all procedures in the contract router.
+   * The provided prefix is post-appended to any existing router prefix.
+   *
+   * @note This option does not affect procedures that do not define a path in their route definition.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
+   */
   prefix(prefix) {
     return new ContractBuilder({
       ...this["~orpc"],
       prefix: mergePrefix(this["~orpc"].prefix, prefix)
     });
   }
+  /**
+   * Adds tags to all procedures in the contract router.
+   * This helpful when you want to group procedures together in the OpenAPI specification.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+   */
   tag(...tags) {
     return new ContractBuilder({
       ...this["~orpc"],
       tags: mergeTags(this["~orpc"].tags, tags)
     });
   }
+  /**
+   * Applies all of the previously defined options to the specified contract router.
+   *
+   * @see {@link https://orpc.unnoq.com/docs/router#extending-router Extending Router Docs}
+   */
   router(router) {
-    return adaptContractRouter(router, this["~orpc"]);
+    return enhanceContractRouter(router, this["~orpc"]);
   }
 }
 const oc = new ContractBuilder({
   errorMap: {},
-  inputSchema: void 0,
-  outputSchema: void 0,
   route: {},
   meta: {}
 });
@@ -179,16 +235,16 @@ function fallbackContractConfig(key, value) {
   return value;
 }
 
-const EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_DETAILS");
 function eventIterator(yields, returns) {
   return {
     "~standard": {
-      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
+      [EVENT_ITERATOR_DETAILS_SYMBOL]: { yields, returns },
       vendor: "orpc",
       version: 1,
       validate(iterator) {
         if (!isAsyncIteratorObject(iterator)) {
-          return { issues: [{ message: "Expect event source iterator", path: [] }] };
+          return { issues: [{ message: "Expect event iterator", path: [] }] };
         }
         const mapped = mapEventIterator(iterator, {
           async value(value, done) {
@@ -199,10 +255,11 @@ function eventIterator(yields, returns) {
             const result = await schema["~standard"].validate(value);
             if (result.issues) {
               throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
-                message: "Event source iterator validation failed",
+                message: "Event iterator validation failed",
                 cause: new ValidationError({
                   issues: result.issues,
-                  message: "Event source iterator validation failed"
+                  message: "Event iterator validation failed",
+                  data: value
                 })
               });
             }
@@ -219,7 +276,20 @@ function getEventIteratorSchemaDetails(schema) {
   if (schema === void 0) {
     return void 0;
   }
-  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
+  return schema["~standard"][EVENT_ITERATOR_DETAILS_SYMBOL];
+}
+
+function inferRPCMethodFromContractRouter(contract) {
+  return (_, path) => {
+    const procedure = get(contract, path);
+    if (!isContractProcedure(procedure)) {
+      throw new Error(
+        `[inferRPCMethodFromContractRouter] No valid procedure found at path "${path.join(".")}". This may happen when the contract router is not properly configured.`
+      );
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    return method === "HEAD" ? "GET" : method;
+  };
 }
 
 function type(...[map]) {
@@ -237,4 +307,19 @@ function type(...[map]) {
   };
 }
 
-export { ContractBuilder, ContractProcedure, ValidationError, adaptContractRouter, adaptRoute, eventIterator, fallbackContractConfig, getEventIteratorSchemaDetails, isContractProcedure, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, oc, prefixRoute, type, unshiftTagRoute };
+function isSchemaIssue(issue) {
+  if (!isTypescriptObject(issue) || typeof issue.message !== "string") {
+    return false;
+  }
+  if (issue.path !== void 0) {
+    if (!Array.isArray(issue.path)) {
+      return false;
+    }
+    if (!issue.path.every((segment) => isPropertyKey(segment) || isTypescriptObject(segment) && isPropertyKey(segment.key))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export { ContractBuilder, ContractProcedure, ValidationError, enhanceContractRouter, enhanceRoute, eventIterator, fallbackContractConfig, getContractRouter, getEventIteratorSchemaDetails, inferRPCMethodFromContractRouter, isContractProcedure, isSchemaIssue, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, minifyContractRouter, oc, prefixRoute, type, unshiftTagRoute };

package/dist/plugins/index.d.mts

@@ -0,0 +1,24 @@
+import { ClientContext } from '@orpc/client';
+import { StandardLinkPlugin, StandardLinkOptions } from '@orpc/client/standard';
+import { A as AnyContractRouter } from '../shared/contract.CvRxURhn.mjs';
+import '@orpc/shared';
+import '@standard-schema/spec';
+import 'openapi-types';
+
+/**
+ * A link plugin that validates server responses against your contract schema,
+ * ensuring that data returned from your server matches the expected types defined in your contract.
+ *
+ * - Throws `ValidationError` if output doesn't match the expected schema
+ * - Converts mismatched defined errors to normal `ORPCError` instances
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/response-validation Response Validation Plugin Docs}
+ */
+declare class ResponseValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ResponseValidationPlugin };

package/dist/plugins/index.d.ts

@@ -0,0 +1,24 @@
+import { ClientContext } from '@orpc/client';
+import { StandardLinkPlugin, StandardLinkOptions } from '@orpc/client/standard';
+import { A as AnyContractRouter } from '../shared/contract.CvRxURhn.js';
+import '@orpc/shared';
+import '@standard-schema/spec';
+import 'openapi-types';
+
+/**
+ * A link plugin that validates server responses against your contract schema,
+ * ensuring that data returned from your server matches the expected types defined in your contract.
+ *
+ * - Throws `ValidationError` if output doesn't match the expected schema
+ * - Converts mismatched defined errors to normal `ORPCError` instances
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/response-validation Response Validation Plugin Docs}
+ */
+declare class ResponseValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ResponseValidationPlugin };

package/dist/plugins/index.mjs

@@ -0,0 +1,43 @@
+import { ORPCError } from '@orpc/client';
+import { get } from '@orpc/shared';
+import { i as isContractProcedure, V as ValidationError, v as validateORPCError } from '../shared/contract.D_dZrO__.mjs';
+
+class ResponseValidationPlugin {
+  constructor(contract) {
+    this.contract = contract;
+  }
+  order = 15e5;
+  // make sure run before DurableEventIteratorLinkPlugin
+  init(options) {
+    options.interceptors ??= [];
+    options.interceptors.push(async ({ next, path }) => {
+      const procedure = get(this.contract, path);
+      if (!isContractProcedure(procedure)) {
+        throw new Error(`[ResponseValidationPlugin] no valid procedure found at path "${path.join(".")}", this may happen when the contract router is not properly configured.`);
+      }
+      try {
+        const output = await next();
+        const outputSchema = procedure["~orpc"].outputSchema;
+        if (!outputSchema) {
+          return output;
+        }
+        const result = await outputSchema["~standard"].validate(output);
+        if (result.issues) {
+          throw new ValidationError({
+            message: "Server response output does not match expected schema",
+            issues: result.issues,
+            data: output
+          });
+        }
+        return result.value;
+      } catch (e) {
+        if (e instanceof ORPCError) {
+          throw await validateORPCError(procedure["~orpc"].errorMap, e);
+        }
+        throw e;
+      }
+    });
+  }
+}
+
+export { ResponseValidationPlugin };

package/dist/shared/contract.CvRxURhn.d.mts

@@ -0,0 +1,254 @@
+import { ORPCErrorCode, ORPCError, HTTPMethod, HTTPPath } from '@orpc/client';
+import { Promisable, IsEqual, ThrowableError } from '@orpc/shared';
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { OpenAPIV3_1 } from 'openapi-types';
+
+type Schema<TInput, TOutput> = StandardSchemaV1<TInput, TOutput>;
+type AnySchema = Schema<any, any>;
+type SchemaIssue = StandardSchemaV1.Issue;
+type InferSchemaInput<T extends AnySchema> = T extends StandardSchemaV1<infer UInput, any> ? UInput : never;
+type InferSchemaOutput<T extends AnySchema> = T extends StandardSchemaV1<any, infer UOutput> ? UOutput : never;
+type TypeRest<TInput, TOutput> = [map: (input: TInput) => Promisable<TOutput>] | (IsEqual<TInput, TOutput> extends true ? [] : never);
+/**
+ * The schema for things can be trust without validation.
+ * If the TInput and TOutput are different, you need pass a map function.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/procedure#type-utility Type Utility Docs}
+ */
+declare function type<TInput, TOutput = TInput>(...[map]: TypeRest<TInput, TOutput>): Schema<TInput, TOutput>;
+
+interface ValidationErrorOptions extends ErrorOptions {
+    message: string;
+    issues: readonly SchemaIssue[];
+    /**
+     * @todo require this field in v2
+     */
+    data?: unknown;
+}
+/**
+ * This errors usually used for ORPCError.cause when the error is a validation error.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/advanced/validation-errors Validation Errors Docs}
+ */
+declare class ValidationError extends Error {
+    readonly issues: readonly SchemaIssue[];
+    readonly data: unknown;
+    constructor(options: ValidationErrorOptions);
+}
+interface ErrorMapItem<TDataSchema extends AnySchema> {
+    status?: number;
+    message?: string;
+    data?: TDataSchema;
+}
+type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
+};
+type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown, unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+type ErrorFromErrorMap<TErrorMap extends ErrorMap> = ORPCErrorFromErrorMap<TErrorMap> | ThrowableError;
+declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
+
+type Meta = Record<string, any>;
+declare function mergeMeta<T extends Meta>(meta1: T, meta2: T): T;
+
+type InputStructure = 'compact' | 'detailed';
+type OutputStructure = 'compact' | 'detailed';
+interface Route {
+    /**
+     * The HTTP method of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+     */
+    method?: HTTPMethod;
+    /**
+     * The HTTP path of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+     */
+    path?: HTTPPath;
+    /**
+     * The operation ID of the endpoint.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @default Concatenation of router segments
+     */
+    operationId?: string;
+    /**
+     * The summary of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    summary?: string;
+    /**
+     * The description of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    description?: string;
+    /**
+     * Marks the procedure as deprecated.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    deprecated?: boolean;
+    /**
+     * The tags of the procedure.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     */
+    tags?: readonly string[];
+    /**
+     * The status code of the response when the procedure is successful.
+     * The status code must be in the 200-399 range.
+     * This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/routing OpenAPI Routing Docs}
+     * @default 200
+     */
+    successStatus?: number;
+    /**
+     * The description of the response when the procedure is successful.
+     *  This option is typically relevant when integrating with OpenAPI.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
+     * @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' },
+     * }
+     * ```
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     * @default 'compact'
+     */
+    inputStructure?: InputStructure;
+    /**
+     * Determines how the response should be structured based on the output.
+     *
+     * @option 'compact'
+     * The output data is directly returned as the response body.
+     *
+     * @option 'detailed'
+     * Return an object with optional properties:
+     * - `status`: The response status (must be in 200-399 range) if not set fallback to `successStatus`.
+     * - `headers`: Custom headers to merge with the response headers (`Record<string, string | string[] | undefined>`)
+     * - `body`: The response body.
+     *
+     * Example:
+     * ```ts
+     * const output = {
+     *   status: 201,
+     *   headers: { 'x-custom-header': 'value' },
+     *   body: { message: 'Hello, world!' },
+     * };
+     * ```
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
+     * @default 'compact'
+     */
+    outputStructure?: OutputStructure;
+    /**
+     * Override entire auto-generated OpenAPI Operation Object Specification.
+     *
+     * @see {@link https://orpc.unnoq.com/docs/openapi/openapi-specification#operation-metadata Operation Metadata Docs}
+     */
+    spec?: OpenAPIV3_1.OperationObject | ((current: OpenAPIV3_1.OperationObject) => OpenAPIV3_1.OperationObject);
+}
+declare function mergeRoute(a: Route, b: Route): Route;
+declare function prefixRoute(route: Route, prefix: HTTPPath): Route;
+declare function unshiftTagRoute(route: Route, tags: readonly string[]): Route;
+declare function mergePrefix(a: HTTPPath | undefined, b: HTTPPath): HTTPPath;
+declare function mergeTags(a: readonly string[] | undefined, b: readonly string[]): readonly string[];
+interface EnhanceRouteOptions {
+    prefix?: HTTPPath;
+    tags?: readonly string[];
+}
+declare function enhanceRoute(route: Route, options: EnhanceRouteOptions): Route;
+
+interface ContractProcedureDef<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    meta: TMeta;
+    route: Route;
+    inputSchema?: TInputSchema;
+    outputSchema?: TOutputSchema;
+    errorMap: TErrorMap;
+}
+/**
+ * This class represents a contract procedure.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#procedure-contract Contract Procedure Docs}
+ */
+declare class ContractProcedure<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TMeta extends Meta> {
+    /**
+     * This property holds the defined options for the contract procedure.
+     */
+    '~orpc': ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>;
+    constructor(def: ContractProcedureDef<TInputSchema, TOutputSchema, TErrorMap, TMeta>);
+}
+type AnyContractProcedure = ContractProcedure<any, any, any, any>;
+declare function isContractProcedure(item: unknown): item is AnyContractProcedure;
+
+/**
+ * Represents a contract router, which defines a hierarchical structure of contract procedures.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#contract-router Contract Router Docs}
+ */
+type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {
+    [k: string]: ContractRouter<TMeta>;
+};
+type AnyContractRouter = ContractRouter<any>;
+/**
+ * Infer all inputs of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterInputs<T extends AnyContractRouter> = T extends ContractProcedure<infer UInputSchema, any, any, any> ? InferSchemaInput<UInputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterInputs<T[K]> : never;
+};
+/**
+ * Infer all outputs of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterOutputs<T extends AnyContractRouter> = T extends ContractProcedure<any, infer UOutputSchema, any, any> ? InferSchemaOutput<UOutputSchema> : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterOutputs<T[K]> : never;
+};
+/**
+ * Infer all errors of the contract router.
+ *
+ * @info A contract procedure is a contract router too.
+ * @see {@link https://orpc.unnoq.com/docs/contract-first/define-contract#utilities Contract Utilities Docs}
+ */
+type InferContractRouterErrorMap<T extends AnyContractRouter> = T extends ContractProcedure<any, any, infer UErrorMap, any> ? UErrorMap : {
+    [K in keyof T]: T[K] extends AnyContractRouter ? InferContractRouterErrorMap<T[K]> : never;
+}[keyof T];
+type InferContractRouterMeta<T extends AnyContractRouter> = T extends ContractRouter<infer UMeta> ? UMeta : never;
+
+export { ContractProcedure as C, type as D, ValidationError as j, mergeErrorMap as m, mergeMeta as n, isContractProcedure as p, mergeRoute as q, prefixRoute as r, mergePrefix as s, mergeTags as t, unshiftTagRoute as u, validateORPCError as v, enhanceRoute as w };
+export type { AnyContractRouter as A, InferContractRouterMeta as B, ErrorMap as E, InputStructure as I, MergedErrorMap as M, OutputStructure as O, Route as R, Schema as S, TypeRest as T, ValidationErrorOptions as V, EnhanceRouteOptions as a, AnySchema as b, Meta as c, ContractRouter as d, ContractProcedureDef as e, InferSchemaInput as f, InferSchemaOutput as g, ErrorFromErrorMap as h, SchemaIssue as i, ErrorMapItem as k, ORPCErrorFromErrorMap as l, AnyContractProcedure as o, InferContractRouterInputs as x, InferContractRouterOutputs as y, InferContractRouterErrorMap as z };