@orpc/contract 1.14.11 → 1.14.13

package/dist/shared/contract.TuRtB1Ca.d.ts

@@ -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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "1.14.11",
+  "version": "1.14.13",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -14,7 +14,6 @@
   ],
   "sideEffects": false,
   "exports": {
-    "./package.json": "./package.json",
     ".": {
       "types": "./dist/index.d.mts",
       "import": "./dist/index.mjs",
@@ -31,16 +30,18 @@
   ],
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "@orpc/shared": "1.14.11",
-    "@orpc/client": "1.14.11"
+    "openapi-types": "^12.1.3",
+    "@orpc/client": "1.14.13",
+    "@orpc/shared": "1.14.13"
   },
   "devDependencies": {
-    "arktype": "^2.2.1",
-    "valibot": "^1.4.1",
-    "zod": "^4.4.3"
+    "arktype": "2.2.0",
+    "valibot": "^1.2.0",
+    "zod": "^4.3.6"
   },
   "scripts": {
     "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }
 }

package/dist/shared/contract.CW-2wl1i.mjs

@@ -1,180 +0,0 @@
-import { toArray, getConstructor, isTypescriptObject } from '@orpc/shared';
-import { cloneORPCError } from '@orpc/client';
-
-function mergeErrorMap(errorMap1, errorMap2) {
-  return { ...errorMap1, ...errorMap2 };
-}
-async function reconcileORPCError(map, error) {
-  const config = map[error.code];
-  if (!config) {
-    if (!error.defined) {
-      return error;
-    }
-    const cloned2 = cloneORPCError(error);
-    cloned2.defined = false;
-    cloned2.inferable = false;
-    return cloned2;
-  }
-  if (!config.data) {
-    if (error.defined && error.inferable) {
-      return error;
-    }
-    const cloned2 = cloneORPCError(error);
-    cloned2.defined = true;
-    cloned2.inferable = true;
-    return cloned2;
-  }
-  const validated = await config.data["~standard"].validate(error.data);
-  if (validated.issues) {
-    if (!error.defined) {
-      return error;
-    }
-    const cloned2 = cloneORPCError(error);
-    cloned2.defined = false;
-    cloned2.inferable = false;
-    return cloned2;
-  }
-  if (error.data === validated.value && error.defined && error.inferable) {
-    return error;
-  }
-  const cloned = cloneORPCError(error);
-  cloned.data = validated.value;
-  cloned.defined = true;
-  cloned.inferable = true;
-  return cloned;
-}
-
-function resolveMetaPlugins(baseMeta, existingPlugins, incomingPlugins) {
-  existingPlugins = toArray(existingPlugins);
-  incomingPlugins = toArray(incomingPlugins);
-  let meta = baseMeta;
-  for (const plugin of incomingPlugins) {
-    if (plugin.init) {
-      meta = plugin.init(meta);
-    }
-  }
-  const plugins = [...existingPlugins, ...incomingPlugins];
-  for (const plugin of plugins) {
-    if (plugin.apply) {
-      meta = plugin.apply(meta);
-    }
-  }
-  return [meta, plugins];
-}
-function defineMeta(name, merge) {
-  const metaPlugin = (value) => ({
-    name,
-    init: (meta) => {
-      const current = meta[name];
-      return {
-        ...meta,
-        [name]: merge(value, current)
-      };
-    }
-  });
-  const getMeta = (procedureOrLazy) => procedureOrLazy["~orpc"].meta[name];
-  return [metaPlugin, getMeta];
-}
-
-class ProcedureContract {
-  "~orpc";
-  constructor(def) {
-    this["~orpc"] = def;
-  }
-  /**
-   * Checks if the given instance satisfies the {@see ProcedureContract} class/interface.
-   */
-  static [Symbol.hasInstance](instance) {
-    if (this !== ProcedureContract) {
-      return Function.prototype[Symbol.hasInstance].call(this, instance);
-    }
-    const constructor = getConstructor(instance);
-    if (constructor === ProcedureContract) {
-      return true;
-    }
-    return isTypescriptObject(instance) && isTypescriptObject(instance["~orpc"]) && isTypescriptObject(instance["~orpc"].errorMap) && isTypescriptObject(instance["~orpc"].meta) && (instance["~orpc"].inputSchemas === void 0 || Array.isArray(instance["~orpc"].inputSchemas)) && (instance["~orpc"].outputSchemas === void 0 || Array.isArray(instance["~orpc"].outputSchemas));
-  }
-}
-
-function augmentContractRouter(router, options) {
-  if (router instanceof ProcedureContract) {
-    const [meta, metaPlugins] = resolveMetaPlugins(
-      options.meta,
-      options.metaPlugins,
-      router["~orpc"].metaPlugins
-    );
-    const enhanced2 = new ProcedureContract({
-      ...router["~orpc"],
-      errorMap: mergeErrorMap(options.errorMap, router["~orpc"].errorMap),
-      meta,
-      metaPlugins
-    });
-    return enhanced2;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentContractRouter(router[key], options);
-  }
-  return enhanced;
-}
-function getRouterContract(router, path) {
-  let current = router;
-  for (let i = 0; i < path.length; i++) {
-    const segment = path[i];
-    if (!isTypescriptObject(current)) {
-      return void 0;
-    }
-    if (current instanceof ProcedureContract) {
-      return void 0;
-    }
-    current = current[segment];
-  }
-  if (!isTypescriptObject(current)) {
-    return void 0;
-  }
-  return current;
-}
-function getProcedureContractOrThrow(router, path) {
-  const procedure = getRouterContract(router, path);
-  if (!(procedure instanceof ProcedureContract)) {
-    throw new TypeError(`No valid procedure found at path "${path.join(".")}", this may happen when the router contract is not properly configured.`);
-  }
-  return procedure;
-}
-function minifyRouterContract(router) {
-  if (router instanceof ProcedureContract) {
-    const procedure = {
-      "~orpc": {
-        errorMap: {},
-        meta: router["~orpc"].meta
-      }
-    };
-    return procedure;
-  }
-  if (!isTypescriptObject(router)) {
-    return router;
-  }
-  const json = {};
-  for (const key in router) {
-    json[key] = minifyRouterContract(router[key]);
-  }
-  return json;
-}
-
-class ValidationError extends Error {
-  /**
-   * This array is readonly because the upstream Standard Schema returns readonly issues.
-   */
-  issues;
-  invalidData;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
-    this.invalidData = options.invalidData;
-  }
-}
-
-export { ProcedureContract as P, ValidationError as V, augmentContractRouter as a, getRouterContract as b, minifyRouterContract as c, defineMeta as d, reconcileORPCError as e, getProcedureContractOrThrow as g, mergeErrorMap as m, resolveMetaPlugins as r };

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

@@ -1,126 +0,0 @@
-import { ThrowableError } from '@orpc/shared';
-import { ORPCErrorCode, ORPCError } from '@orpc/client';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-
-/**
- * TOutput default = TInput for better readability (shorter) in-case both TInput, TOutput is equal
- */
-type Schema<TInput, TOutput = TInput> = StandardSchemaV1<TInput, TOutput>;
-type AnySchema = Schema<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 MergedSchema<T extends AnySchema, U extends AnySchema> = T extends Schema<infer TInput, infer TOutput> ? U extends Schema<infer UInput, infer UOutput> ? Schema<TInput & UInput, TOutput & UOutput> : never : never;
-
-interface ErrorMapItem<TDataSchema extends AnySchema> {
-    message?: string;
-    data?: TDataSchema;
-}
-type ErrorMap = {
-    [key in ORPCErrorCode]?: ErrorMapItem<AnySchema>;
-};
-type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
-    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema extends Schema<unknown>> ? ORPCError<K, InferSchemaOutput<TDataSchema>> : never : never;
-}[keyof TErrorMap];
-interface ValidationErrorOptions extends ErrorOptions {
-    message: string;
-    issues: readonly SchemaIssue[];
-    invalidData: unknown;
-}
-declare class ValidationError extends Error {
-    /**
-     * This array is readonly because the upstream Standard Schema returns readonly issues.
-     */
-    issues: readonly SchemaIssue[];
-    invalidData: unknown;
-    constructor(options: ValidationErrorOptions);
-}
-
-interface Meta {
-    [key: PropertyKey]: unknown;
-}
-interface MetaPluginDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    __TInputSchema?: {
-        type: TInputSchema;
-    };
-    __TOutputSchema?: {
-        type: TOutputSchema;
-    };
-    __TErrorMap?: {
-        type: TErrorMap;
-    };
-}
-interface MetaPlugin<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    /** This only for types, so it should be optional */
-    '~orpc'?: MetaPluginDefinition<TInputSchema, TOutputSchema, TErrorMap> | undefined;
-    /** Unique name of the plugin, used for identification. */
-    'name': string;
-    /**
-     * Runs once when this plugin is first added to the builder.
-     * Use this to set up initial metadata values.
-     */
-    'init'?: (meta: Meta) => Meta;
-    /**
-     * Runs every time metadata is updated.
-     * This is called for all plugins in the chain whenever a new plugin is added.
-     */
-    'apply'?: (meta: Meta) => Meta;
-}
-type AnyMetaPlugin = MetaPlugin<any, any, any>;
-declare const HIDDEN_META_PLUGINS_SYMBOL: unique symbol;
-declare function getHiddenMetaPlugins(container: unknown): AnyMetaPlugin[] | undefined;
-declare function setHiddenMetaPlugins<T extends object>(container: T, metaPlugins: AnyMetaPlugin[]): void;
-
-interface ProcedureContractDefinition<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    __TInputSchema?: {
-        type: TInputSchema;
-    };
-    __TOutputSchema?: {
-        type: TOutputSchema;
-    };
-    /**
-     * Non-serializable should be optional
-     */
-    inputSchemas?: AnySchema[] | undefined;
-    outputSchemas?: AnySchema[] | undefined;
-    metaPlugins?: AnyMetaPlugin[] | undefined;
-    errorMap: TErrorMap;
-    meta: Meta;
-}
-declare class ProcedureContract<TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap> {
-    '~orpc': ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>;
-    constructor(def: ProcedureContractDefinition<TInputSchema, TOutputSchema, TErrorMap>);
-    /**
-     * Checks if the given instance satisfies the {@see ProcedureContract} class/interface.
-     */
-    static [Symbol.hasInstance](instance: unknown): boolean;
-}
-type AnyProcedureContract = ProcedureContract<any, any, any>;
-
-type RouterContract = AnyProcedureContract | {
-    [k: string]: RouterContract;
-};
-type InferRouterContractInputs<T extends RouterContract> = T extends ProcedureContract<infer UInputSchema, any, any> ? InferSchemaInput<UInputSchema> : {
-    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractInputs<T[K]> : never;
-};
-type InferRouterContractOutputs<T extends RouterContract> = T extends ProcedureContract<any, infer UOutputSchema, any> ? InferSchemaOutput<UOutputSchema> : {
-    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractOutputs<T[K]> : never;
-};
-type InferRouterContractErrorMap<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? UErrorMap : {
-    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrorMap<T[K]> : never;
-}[keyof T];
-/**
- * Infer the union of throwable errors for entire router-contract.
- */
-type InferRouterContractError<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
-    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractError<T[K]> : never;
-}[keyof T];
-/**
- * Infer throwable errors for each procedure-contract, preserving the router-contract shape.
- */
-type InferRouterContractErrors<T extends RouterContract> = T extends ProcedureContract<any, any, infer UErrorMap> ? ORPCErrorFromErrorMap<UErrorMap> | ThrowableError : {
-    [K in keyof T]: T[K] extends RouterContract ? InferRouterContractErrors<T[K]> : never;
-};
-
-export { HIDDEN_META_PLUGINS_SYMBOL as H, ProcedureContract as P, ValidationError as V, getHiddenMetaPlugins as p, setHiddenMetaPlugins as s };
-export type { AnySchema as A, ErrorMap as E, InferSchemaInput as I, MetaPlugin as M, ORPCErrorFromErrorMap as O, RouterContract as R, Schema as S, MergedSchema as a, Meta as b, AnyMetaPlugin as c, AnyProcedureContract as d, InferSchemaOutput as e, SchemaIssue as f, ErrorMapItem as g, InferRouterContractError as h, InferRouterContractErrorMap as i, InferRouterContractErrors as j, InferRouterContractInputs as k, InferRouterContractOutputs as l, MetaPluginDefinition as m, ProcedureContractDefinition as n, ValidationErrorOptions as o };