@orpc/contract 0.0.0-next.fc23c8d → 0.0.0-next.fc2dc8f

package/dist/index.mjs

@@ -1,44 +1,15 @@
-import { isORPCErrorStatus, mapEventIterator, ORPCError } from '@orpc/client';
+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 { toHttpPath } from '@orpc/client/standard';
+import { toArray, isAsyncIteratorObject, get, isTypescriptObject, isPropertyKey } from '@orpc/shared';
+export { AsyncIteratorClass } from '@orpc/shared';
+import { mapEventIterator, ORPCError } from '@orpc/client';
 export { ORPCError } from '@orpc/client';
-import { isAsyncIteratorObject, get, isTypescriptObject, isPropertyKey } 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 };
-}
 
 function mergeMeta(meta1, meta2) {
   return { ...meta1, ...meta2 };
 }
 
-class ContractProcedure {
-  /**
-   * This property holds the defined options for the contract procedure.
-   */
-  "~orpc";
-  constructor(def) {
-    if (def.route?.successStatus && isORPCErrorStatus(def.route.successStatus)) {
-      throw new Error("[ContractProcedure] Invalid successStatus.");
-    }
-    if (Object.values(def.errorMap).some((val) => val && val.status && !isORPCErrorStatus(val.status))) {
-      throw new Error("[ContractProcedure] Invalid error status code.");
-    }
-    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 && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
-}
-
 function mergeRoute(a, b) {
   return { ...a, ...b };
 }
@@ -120,6 +91,26 @@ function minifyContractRouter(router) {
   }
   return json;
 }
+function populateContractRouterPaths(router, options = {}) {
+  const path = toArray(options.path);
+  if (isContractProcedure(router)) {
+    if (router["~orpc"].route.path === void 0) {
+      return new ContractProcedure({
+        ...router["~orpc"],
+        route: {
+          ...router["~orpc"].route,
+          path: toHttpPath(path)
+        }
+      });
+    }
+    return router;
+  }
+  const populated = {};
+  for (const key in router) {
+    populated[key] = populateContractRouterPaths(router[key], { ...options, path: [...path, key] });
+  }
+  return populated;
+}
 
 class ContractBuilder extends ContractProcedure {
   constructor(def) {
@@ -130,7 +121,7 @@ class ContractBuilder extends ContractProcedure {
   /**
    * Sets or overrides the initial meta.
    *
-   * @see {@link https://orpc.unnoq.com/docs/metadata Metadata Docs}
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
    */
   $meta(initialMeta) {
     return new ContractBuilder({
@@ -142,8 +133,8 @@ class ContractBuilder extends ContractProcedure {
    * 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}
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
   $route(initialRoute) {
     return new ContractBuilder({
@@ -151,11 +142,22 @@ class ContractBuilder extends ContractProcedure {
       route: initialRoute
     });
   }
+  /**
+   * Sets or overrides the initial input schema.
+   *
+   * @see {@link https://orpc.dev/docs/procedure#initial-configuration Initial Procedure Configuration Docs}
+   */
+  $input(initialInputSchema) {
+    return new ContractBuilder({
+      ...this["~orpc"],
+      inputSchema: initialInputSchema
+    });
+  }
   /**
    * 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}
+   * @see {@link https://orpc.dev/docs/error-handling#type%E2%80%90safe-error-handling Type-Safe Error Handling Docs}
    */
   errors(errors) {
     return new ContractBuilder({
@@ -167,7 +169,7 @@ class ContractBuilder extends ContractProcedure {
    * 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}
+   * @see {@link https://orpc.dev/docs/metadata Metadata Docs}
    */
   meta(meta) {
     return new ContractBuilder({
@@ -180,8 +182,8 @@ class ContractBuilder extends ContractProcedure {
    * 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}
+   * @see {@link https://orpc.dev/docs/openapi/routing OpenAPI Routing Docs}
+   * @see {@link https://orpc.dev/docs/openapi/input-output-structure OpenAPI Input/Output Structure Docs}
    */
   route(route) {
     return new ContractBuilder({
@@ -192,7 +194,7 @@ class ContractBuilder extends ContractProcedure {
   /**
    * Defines the input validation schema for the contract.
    *
-   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Input Validation Docs}
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Input Validation Docs}
    */
   input(schema) {
     return new ContractBuilder({
@@ -203,7 +205,7 @@ class ContractBuilder extends ContractProcedure {
   /**
    * Defines the output validation schema for the contract.
    *
-   * @see {@link https://orpc.unnoq.com/docs/procedure#input-output-validation Output Validation Docs}
+   * @see {@link https://orpc.dev/docs/procedure#input-output-validation Output Validation Docs}
    */
   output(schema) {
     return new ContractBuilder({
@@ -217,7 +219,7 @@ class ContractBuilder extends ContractProcedure {
    *
    * @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}
+   * @see {@link https://orpc.dev/docs/openapi/routing#route-prefixes OpenAPI Route Prefixes Docs}
    */
   prefix(prefix) {
     return new ContractBuilder({
@@ -229,7 +231,7 @@ class ContractBuilder extends ContractProcedure {
    * 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}
+   * @see {@link https://orpc.dev/docs/openapi/openapi-specification#operation-metadata OpenAPI Operation Metadata Docs}
    */
   tag(...tags) {
     return new ContractBuilder({
@@ -240,7 +242,7 @@ class ContractBuilder extends ContractProcedure {
   /**
    * 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}
+   * @see {@link https://orpc.dev/docs/router#extending-router Extending Router Docs}
    */
   router(router) {
     return enhanceContractRouter(router, this["~orpc"]);
@@ -289,7 +291,8 @@ function eventIterator(yields, returns) {
                 message: "Event iterator validation failed",
                 cause: new ValidationError({
                   issues: result.issues,
-                  message: "Event iterator validation failed"
+                  message: "Event iterator validation failed",
+                  data: value
                 })
               });
             }
@@ -352,4 +355,4 @@ function isSchemaIssue(issue) {
   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 };
+export { ContractBuilder, ContractProcedure, ValidationError, enhanceContractRouter, enhanceRoute, eventIterator, fallbackContractConfig, getContractRouter, getEventIteratorSchemaDetails, inferRPCMethodFromContractRouter, isContractProcedure, isSchemaIssue, mergeErrorMap, mergeMeta, mergePrefix, mergeRoute, mergeTags, minifyContractRouter, oc, populateContractRouterPaths, prefixRoute, type, unshiftTagRoute };

package/dist/plugins/index.d.mts

@@ -0,0 +1,43 @@
+import { ClientContext } from '@orpc/client';
+import { StandardLinkPlugin, StandardLinkOptions } from '@orpc/client/standard';
+import { A as AnyContractRouter } from '../shared/contract.TuRtB1Ca.mjs';
+import '@orpc/shared';
+import '@standard-schema/spec';
+import 'openapi-types';
+
+declare class RequestValidationPluginError extends Error {
+}
+/**
+ * A link plugin that validates client requests against your contract schema,
+ * ensuring that data sent to your server matches the expected types defined in your contract.
+ *
+ * @throws {ORPCError} with code `BAD_REQUEST` (same as server side) if input doesn't match the expected schema
+ * @see {@link https://orpc.dev/docs/plugins/request-validation Request Validation Plugin Docs}
+ */
+declare class RequestValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+/**
+ * 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.dev/docs/plugins/response-validation Response Validation Plugin Docs}
+ */
+declare class ResponseValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    /**
+     * run before (validate after) retry plugin, because validation failed can't be retried
+     * run before (validate after) durable iterator plugin, because we expect durable iterator to validation (if user use it)
+     */
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { RequestValidationPlugin, RequestValidationPluginError, ResponseValidationPlugin };

package/dist/plugins/index.d.ts

@@ -0,0 +1,43 @@
+import { ClientContext } from '@orpc/client';
+import { StandardLinkPlugin, StandardLinkOptions } from '@orpc/client/standard';
+import { A as AnyContractRouter } from '../shared/contract.TuRtB1Ca.js';
+import '@orpc/shared';
+import '@standard-schema/spec';
+import 'openapi-types';
+
+declare class RequestValidationPluginError extends Error {
+}
+/**
+ * A link plugin that validates client requests against your contract schema,
+ * ensuring that data sent to your server matches the expected types defined in your contract.
+ *
+ * @throws {ORPCError} with code `BAD_REQUEST` (same as server side) if input doesn't match the expected schema
+ * @see {@link https://orpc.dev/docs/plugins/request-validation Request Validation Plugin Docs}
+ */
+declare class RequestValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+/**
+ * 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.dev/docs/plugins/response-validation Response Validation Plugin Docs}
+ */
+declare class ResponseValidationPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly contract;
+    constructor(contract: AnyContractRouter);
+    /**
+     * run before (validate after) retry plugin, because validation failed can't be retried
+     * run before (validate after) durable iterator plugin, because we expect durable iterator to validation (if user use it)
+     */
+    order: number;
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { RequestValidationPlugin, RequestValidationPluginError, ResponseValidationPlugin };

package/dist/plugins/index.mjs

@@ -0,0 +1,81 @@
+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 RequestValidationPluginError extends Error {
+}
+class RequestValidationPlugin {
+  constructor(contract) {
+    this.contract = contract;
+  }
+  init(options) {
+    options.interceptors ??= [];
+    options.interceptors.push(async ({ next, path, input }) => {
+      const procedure = get(this.contract, path);
+      if (!isContractProcedure(procedure)) {
+        throw new RequestValidationPluginError(`No valid procedure found at path "${path.join(".")}", this may happen when the contract router is not properly configured.`);
+      }
+      const inputSchema = procedure["~orpc"].inputSchema;
+      if (inputSchema) {
+        const result = await inputSchema["~standard"].validate(input);
+        if (result.issues) {
+          throw new ORPCError("BAD_REQUEST", {
+            message: "Input validation failed",
+            data: {
+              issues: result.issues
+            },
+            cause: new ValidationError({
+              message: "Input validation failed",
+              issues: result.issues,
+              data: input
+            })
+          });
+        }
+      }
+      return await next();
+    });
+  }
+}
+
+class ResponseValidationPlugin {
+  constructor(contract) {
+    this.contract = contract;
+  }
+  /**
+   * run before (validate after) retry plugin, because validation failed can't be retried
+   * run before (validate after) durable iterator plugin, because we expect durable iterator to validation (if user use it)
+   */
+  order = 12e5;
+  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 { RequestValidationPlugin, RequestValidationPluginError, ResponseValidationPlugin };

package/dist/shared/contract.D_dZrO__.mjs

@@ -0,0 +1,53 @@
+import { fallbackORPCErrorStatus, ORPCError, isORPCErrorStatus } from '@orpc/client';
+
+class ValidationError extends Error {
+  issues;
+  data;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+    this.data = options.data;
+  }
+}
+function mergeErrorMap(errorMap1, errorMap2) {
+  return { ...errorMap1, ...errorMap2 };
+}
+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(code, { defined: false, status, message, data, cause }) : error;
+  }
+  if (!config.data) {
+    return defined ? error : new ORPCError(code, { defined: true, status, message, data, cause });
+  }
+  const validated = await config.data["~standard"].validate(error.data);
+  if (validated.issues) {
+    return defined ? new ORPCError(code, { defined: false, status, message, data, cause }) : error;
+  }
+  return new ORPCError(code, { defined: true, status, message, data: validated.value, cause });
+}
+
+class ContractProcedure {
+  /**
+   * This property holds the defined options for the contract procedure.
+   */
+  "~orpc";
+  constructor(def) {
+    if (def.route?.successStatus && isORPCErrorStatus(def.route.successStatus)) {
+      throw new Error("[ContractProcedure] Invalid successStatus.");
+    }
+    if (Object.values(def.errorMap).some((val) => val && val.status && !isORPCErrorStatus(val.status))) {
+      throw new Error("[ContractProcedure] Invalid error status code.");
+    }
+    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 && "errorMap" in item["~orpc"] && "route" in item["~orpc"] && "meta" in item["~orpc"];
+}
+
+export { ContractProcedure as C, ValidationError as V, isContractProcedure as i, mergeErrorMap as m, validateORPCError as v };

package/dist/shared/contract.TuRtB1Ca.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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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.dev/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 };