@orpc/contract 0.39.0 → 0.41.0

package/dist/index.js

@@ -1,4 +1,11 @@
-// src/error-map.ts
+// src/error.ts
+var ValidationError = class extends Error {
+  issues;
+  constructor(options) {
+    super(options.message, options);
+    this.issues = options.issues;
+  }
+};
 function mergeErrorMap(errorMap1, errorMap2) {
   return { ...errorMap1, ...errorMap2 };
 }
@@ -160,186 +167,6 @@ var oc = new ContractBuilder({
   meta: {}
 });
 
-// src/error-orpc.ts
-import { isObject } from "@orpc/shared";
-var COMMON_ORPC_ERROR_DEFS = {
-  BAD_REQUEST: {
-    status: 400,
-    message: "Bad Request"
-  },
-  UNAUTHORIZED: {
-    status: 401,
-    message: "Unauthorized"
-  },
-  FORBIDDEN: {
-    status: 403,
-    message: "Forbidden"
-  },
-  NOT_FOUND: {
-    status: 404,
-    message: "Not Found"
-  },
-  METHOD_NOT_SUPPORTED: {
-    status: 405,
-    message: "Method Not Supported"
-  },
-  NOT_ACCEPTABLE: {
-    status: 406,
-    message: "Not Acceptable"
-  },
-  TIMEOUT: {
-    status: 408,
-    message: "Request Timeout"
-  },
-  CONFLICT: {
-    status: 409,
-    message: "Conflict"
-  },
-  PRECONDITION_FAILED: {
-    status: 412,
-    message: "Precondition Failed"
-  },
-  PAYLOAD_TOO_LARGE: {
-    status: 413,
-    message: "Payload Too Large"
-  },
-  UNSUPPORTED_MEDIA_TYPE: {
-    status: 415,
-    message: "Unsupported Media Type"
-  },
-  UNPROCESSABLE_CONTENT: {
-    status: 422,
-    message: "Unprocessable Content"
-  },
-  TOO_MANY_REQUESTS: {
-    status: 429,
-    message: "Too Many Requests"
-  },
-  CLIENT_CLOSED_REQUEST: {
-    status: 499,
-    message: "Client Closed Request"
-  },
-  INTERNAL_SERVER_ERROR: {
-    status: 500,
-    message: "Internal Server Error"
-  },
-  NOT_IMPLEMENTED: {
-    status: 501,
-    message: "Not Implemented"
-  },
-  BAD_GATEWAY: {
-    status: 502,
-    message: "Bad Gateway"
-  },
-  SERVICE_UNAVAILABLE: {
-    status: 503,
-    message: "Service Unavailable"
-  },
-  GATEWAY_TIMEOUT: {
-    status: 504,
-    message: "Gateway Timeout"
-  }
-};
-function fallbackORPCErrorStatus(code, status) {
-  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
-}
-function fallbackORPCErrorMessage(code, message) {
-  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
-}
-var ORPCError = class _ORPCError extends Error {
-  defined;
-  code;
-  status;
-  data;
-  constructor(code, ...[options]) {
-    if (options?.status && (options.status < 400 || options.status >= 600)) {
-      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
-    }
-    const message = fallbackORPCErrorMessage(code, options?.message);
-    super(message, options);
-    this.code = code;
-    this.status = fallbackORPCErrorStatus(code, options?.status);
-    this.defined = options?.defined ?? false;
-    this.data = options?.data;
-  }
-  toJSON() {
-    return {
-      defined: this.defined,
-      code: this.code,
-      status: this.status,
-      message: this.message,
-      data: this.data
-    };
-  }
-  static fromJSON(json) {
-    return new _ORPCError(json.code, json);
-  }
-  static isValidJSON(json) {
-    return isObject(json) && "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
-  }
-};
-
-// src/error-utils.ts
-function isDefinedError(error) {
-  return error instanceof ORPCError && error.defined;
-}
-function createORPCErrorConstructorMap(errors) {
-  const proxy = new Proxy(errors, {
-    get(target, code) {
-      if (typeof code !== "string") {
-        return Reflect.get(target, code);
-      }
-      const item = (...[options]) => {
-        const config = errors[code];
-        return new ORPCError(code, {
-          defined: Boolean(config),
-          status: config?.status,
-          message: options?.message ?? config?.message,
-          data: options?.data,
-          cause: options?.cause
-        });
-      };
-      return item;
-    }
-  });
-  return proxy;
-}
-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 });
-}
-function toORPCError(error) {
-  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
-    message: "Internal server error",
-    cause: error
-  });
-}
-
-// src/client-utils.ts
-async function safe(promise) {
-  try {
-    const output = await promise;
-    return [output, void 0, false];
-  } catch (e) {
-    const error = e;
-    if (isDefinedError(error)) {
-      return [void 0, error, true];
-    }
-    return [void 0, error, false];
-  }
-}
-
 // src/config.ts
 var DEFAULT_CONFIG = {
   defaultMethod: "POST",
@@ -355,14 +182,51 @@ function fallbackContractConfig(key, value) {
   return value;
 }
 
-// src/error.ts
-var ValidationError = class extends Error {
-  issues;
-  constructor(options) {
-    super(options.message, options);
-    this.issues = options.issues;
+// src/event-iterator.ts
+import { mapEventIterator, ORPCError } from "@orpc/client";
+import { isAsyncIteratorObject } from "@orpc/server-standard";
+var EVENT_ITERATOR_SCHEMA_SYMBOL = Symbol("ORPC_EVENT_ITERATOR_SCHEMA");
+function eventIterator(yields, returns) {
+  return {
+    "~standard": {
+      [EVENT_ITERATOR_SCHEMA_SYMBOL]: { yields, returns },
+      vendor: "orpc",
+      version: 1,
+      validate(iterator) {
+        if (!isAsyncIteratorObject(iterator)) {
+          return { issues: [{ message: "Expect event source iterator", path: [] }] };
+        }
+        const mapped = mapEventIterator(iterator, {
+          async value(value, done) {
+            const schema = done ? returns : yields;
+            if (!schema) {
+              return value;
+            }
+            const result = await schema["~standard"].validate(value);
+            if (result.issues) {
+              throw new ORPCError("EVENT_ITERATOR_VALIDATION_FAILED", {
+                message: "Event source iterator validation failed",
+                cause: new ValidationError({
+                  issues: result.issues,
+                  message: "Event source iterator validation failed"
+                })
+              });
+            }
+            return result.value;
+          },
+          error: async (error) => error
+        });
+        return { value: mapped };
+      }
+    }
+  };
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
   }
-};
+  return schema["~standard"][EVENT_ITERATOR_SCHEMA_SYMBOL];
+}
 
 // src/schema.ts
 function type(...[map]) {
@@ -379,20 +243,20 @@ function type(...[map]) {
     }
   };
 }
+
+// src/index.ts
+import { ORPCError as ORPCError2 } from "@orpc/client";
 export {
-  COMMON_ORPC_ERROR_DEFS,
   ContractBuilder,
   ContractProcedure,
-  ORPCError,
+  ORPCError2 as ORPCError,
   ValidationError,
   adaptContractRouter,
   adaptRoute,
-  createORPCErrorConstructorMap,
+  eventIterator,
   fallbackContractConfig,
-  fallbackORPCErrorMessage,
-  fallbackORPCErrorStatus,
+  getEventIteratorSchemaDetails,
   isContractProcedure,
-  isDefinedError,
   mergeErrorMap,
   mergeMeta,
   mergePrefix,
@@ -400,10 +264,7 @@ export {
   mergeTags,
   oc,
   prefixRoute,
-  safe,
-  toORPCError,
   type,
-  unshiftTagRoute,
-  validateORPCError
+  unshiftTagRoute
 };
 //# sourceMappingURL=index.js.map

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

@@ -1,4 +1,4 @@
-import type { ErrorMap, MergedErrorMap } from './error-map';
+import type { ErrorMap, MergedErrorMap } from './error';
 import type { Meta } from './meta';
 import type { ContractProcedure } from './procedure';
 import type { HTTPPath, Route } from './route';

package/dist/src/builder.d.ts

@@ -2,7 +2,7 @@ import type { ContractProcedureBuilder, ContractProcedureBuilderWithInput, Contr
 import type { ContractProcedureDef } from './procedure';
 import type { AdaptContractRouterOptions, AdaptedContractRouter, ContractRouter } from './router';
 import type { Schema } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error-map';
+import { type ErrorMap, type MergedErrorMap } from './error';
 import { type Meta } from './meta';
 import { ContractProcedure } from './procedure';
 import { type HTTPPath, type Route } from './route';

package/dist/src/error.d.ts

@@ -1,7 +1,6 @@
+import type { ORPCError, ORPCErrorCode } from '@orpc/client';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { ErrorMap } from './error-map';
-import type { ORPCErrorFromErrorMap } from './error-orpc';
-export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
+import type { Schema, SchemaOutput } from './schema';
 export interface ValidationErrorOptions extends ErrorOptions {
     message: string;
     issues: readonly StandardSchemaV1.Issue[];
@@ -10,4 +9,19 @@ export declare class ValidationError extends Error {
     readonly issues: readonly StandardSchemaV1.Issue[];
     constructor(options: ValidationErrorOptions);
 }
+export type ErrorMapItem<TDataSchema extends Schema> = {
+    status?: number;
+    message?: string;
+    description?: string;
+    data?: TDataSchema;
+};
+export type ErrorMap = {
+    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
+};
+export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
+export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
+export type ORPCErrorFromErrorMap<TErrorMap extends ErrorMap> = {
+    [K in keyof TErrorMap]: K extends string ? TErrorMap[K] extends ErrorMapItem<infer TDataSchema> ? ORPCError<K, SchemaOutput<TDataSchema>> : never : never;
+}[keyof TErrorMap];
+export type ErrorFromErrorMap<TErrorMap extends ErrorMap> = Error | ORPCErrorFromErrorMap<TErrorMap>;
 //# sourceMappingURL=error.d.ts.map

package/dist/src/event-iterator.d.ts

@@ -0,0 +1,8 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { Schema } from './schema';
+export declare function eventIterator<TYieldIn, TYieldOut, TReturnIn = unknown, TReturnOut = unknown>(yields: StandardSchemaV1<TYieldIn, TYieldOut>, returns?: StandardSchemaV1<TReturnIn, TReturnOut>): StandardSchemaV1<AsyncIteratorObject<TYieldIn, TReturnIn, void>, AsyncIteratorObject<TYieldOut, TReturnOut, void>>;
+export declare function getEventIteratorSchemaDetails(schema: Schema): undefined | {
+    yields: Schema;
+    returns: Schema;
+};
+//# sourceMappingURL=event-iterator.d.ts.map

package/dist/src/index.d.ts

@@ -1,13 +1,9 @@
 /** unnoq */
 export * from './builder';
 export * from './builder-variants';
-export * from './client';
-export * from './client-utils';
 export * from './config';
 export * from './error';
-export * from './error-map';
-export * from './error-orpc';
-export * from './error-utils';
+export * from './event-iterator';
 export * from './meta';
 export * from './procedure';
 export * from './procedure-client';
@@ -15,4 +11,5 @@ export * from './route';
 export * from './router';
 export * from './router-client';
 export * from './schema';
+export { ORPCError } from '@orpc/client';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1,6 +1,5 @@
-import type { Client, ClientContext } from './client';
-import type { ErrorFromErrorMap } from './error';
-import type { ErrorMap } from './error-map';
+import type { Client, ClientContext } from '@orpc/client';
+import type { ErrorFromErrorMap, ErrorMap } from './error';
 import type { Schema, SchemaInput, SchemaOutput } from './schema';
 export type ContractProcedureClient<TClientContext extends ClientContext, 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.d.ts

@@ -1,4 +1,4 @@
-import type { ErrorMap } from './error-map';
+import type { ErrorMap } from './error';
 import type { Meta } from './meta';
 import type { Route } from './route';
 import type { Schema } from './schema';

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

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

package/dist/src/router.d.ts

@@ -1,6 +1,6 @@
 import type { Meta } from './meta';
 import type { SchemaInput, SchemaOutput } from './schema';
-import { type ErrorMap, type MergedErrorMap } from './error-map';
+import { type ErrorMap, type MergedErrorMap } from './error';
 import { ContractProcedure } from './procedure';
 import { type HTTPPath } from './route';
 export type ContractRouter<TMeta extends Meta> = ContractProcedure<any, any, any, TMeta> | {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/contract",
   "type": "module",
-  "version": "0.39.0",
+  "version": "0.41.0",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -29,8 +29,10 @@
     "dist"
   ],
   "dependencies": {
-    "@standard-schema/spec": "1.0.0",
-    "@orpc/shared": "0.39.0"
+    "@orpc/server-standard": "^0.4.0",
+    "@standard-schema/spec": "^1.0.0",
+    "@orpc/client": "0.41.0",
+    "@orpc/shared": "0.41.0"
   },
   "devDependencies": {
     "arktype": "2.0.0-rc.26",

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

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

package/dist/src/client.d.ts

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

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

@@ -1,14 +0,0 @@
-import type { ORPCErrorCode } from './error-orpc';
-import type { Schema } from './schema';
-export type ErrorMapItem<TDataSchema extends Schema> = {
-    status?: number;
-    message?: string;
-    description?: string;
-    data?: TDataSchema;
-};
-export type ErrorMap = {
-    [key in ORPCErrorCode]?: ErrorMapItem<Schema>;
-};
-export type MergedErrorMap<T1 extends ErrorMap, T2 extends ErrorMap> = Omit<T1, keyof T2> & T2;
-export declare function mergeErrorMap<T1 extends ErrorMap, T2 extends ErrorMap>(errorMap1: T1, errorMap2: T2): MergedErrorMap<T1, T2>;
-//# sourceMappingURL=error-map.d.ts.map

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

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

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

@@ -1,15 +0,0 @@
-import type { MaybeOptionalOptions } from '@orpc/shared';
-import type { ErrorMap, ErrorMapItem } from './error-map';
-import type { ORPCErrorCode, ORPCErrorOptions } from './error-orpc';
-import type { SchemaInput } from './schema';
-import { ORPCError } from './error-orpc';
-export declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
-export type ORPCErrorConstructorMapItemOptions<TData> = Omit<ORPCErrorOptions<TData>, 'defined' | 'status'>;
-export type ORPCErrorConstructorMapItem<TCode extends ORPCErrorCode, TInData> = (...rest: MaybeOptionalOptions<ORPCErrorConstructorMapItemOptions<TInData>>) => ORPCError<TCode, TInData>;
-export type ORPCErrorConstructorMap<T extends ErrorMap> = {
-    [K in keyof T]: K extends ORPCErrorCode ? T[K] extends ErrorMapItem<infer UInputSchema> ? ORPCErrorConstructorMapItem<K, SchemaInput<UInputSchema>> : never : never;
-};
-export declare function createORPCErrorConstructorMap<T extends ErrorMap>(errors: T): ORPCErrorConstructorMap<T>;
-export declare function validateORPCError(map: ErrorMap, error: ORPCError<any, any>): Promise<ORPCError<string, unknown>>;
-export declare function toORPCError(error: unknown): ORPCError<any, any>;
-//# sourceMappingURL=error-utils.d.ts.map