@orpc/client 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/shared/client.BYHnU_Z3.mjs

@@ -0,0 +1,469 @@
+import { isPlainObject, wrapAsyncIterator, isTypescriptObject, NullProtoObj, copyOnWrite, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { getEventMeta, withEventMeta, ErrorEvent } from '@standard-server/core';
+import { O as ORPCError, M as MalformedResponseError, C as COMMON_ERROR_STATUS_MAP } from './client.Dtv1JPkU.mjs';
+
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", { cause: error });
+}
+function isORPCErrorJson(json) {
+  if (!isPlainObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  const error = new ORPCError(json.code, {
+    ...json,
+    ...options
+  });
+  error.defined = json.defined;
+  return error;
+}
+function createORPCErrorFromMalformedResponse(options) {
+  const error = new ORPCError("MALFORMED_ORPC_RESPONSE", {
+    message: options.message ?? inferMalformedResponseMessage(options.response),
+    data: options.response
+  });
+  error.cause = new MalformedResponseError({ ...options, message: error.message });
+  return error;
+}
+const INFERRED_MESSAGE_MIN_LENGTH = 1;
+const INFERRED_MESSAGE_MAX_LENGTH = 256;
+function isInferableMessage(text) {
+  return text.length >= INFERRED_MESSAGE_MIN_LENGTH && text.length <= INFERRED_MESSAGE_MAX_LENGTH;
+}
+function inferMalformedResponseMessage(response) {
+  if (typeof response.body === "string" && isInferableMessage(response.body)) {
+    return response.body;
+  }
+  if (isPlainObject(response.body) && typeof response.body.message === "string" && isInferableMessage(response.body.message)) {
+    return response.body.message;
+  }
+  const commonCode = Object.entries(COMMON_ERROR_STATUS_MAP).find(([, status]) => status === response.status)?.[0];
+  return commonCode?.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+function cloneORPCError(error) {
+  const cloned = new ORPCError(error.code, {
+    message: error.message,
+    data: error.data,
+    cause: error.cause
+  });
+  Object.setPrototypeOf(cloned, Object.getPrototypeOf(error));
+  Object.defineProperties(cloned, Object.getOwnPropertyDescriptors(error));
+  cloned.stack = error.stack;
+  return cloned;
+}
+
+function wrapAsyncIteratorPreservingEventMeta(iterator, { mapResult, mapError, ...rest }) {
+  return wrapAsyncIterator(iterator, {
+    ...rest,
+    mapResult: mapResult && (async (result) => {
+      const mapped = await mapResult(result);
+      if (mapped.value !== result.value) {
+        const meta = getEventMeta(result.value);
+        if (meta && isTypescriptObject(mapped.value)) {
+          return { done: mapped.done, value: withEventMeta(mapped.value, meta) };
+        }
+      }
+      return mapped;
+    }),
+    mapError: mapError && (async (error) => {
+      const mapped = await mapError(error);
+      if (mapped !== error) {
+        const meta = getEventMeta(error);
+        if (meta && isTypescriptObject(mapped)) {
+          return withEventMeta(mapped, meta);
+        }
+      }
+      return mapped;
+    })
+  });
+}
+
+function invalidSerializedData(detail) {
+  return new TypeError(`Invalid RPC serialized data: ${detail}`);
+}
+function assertSerializedType(ok, type, expected) {
+  if (!ok) {
+    throw invalidSerializedData(`type "${type}" expects ${expected}.`);
+  }
+}
+const DEFAULT_RPC_JSON_SERIALIZER_HANDLERS = {
+  undefined: {
+    condition(data) {
+      return data === void 0;
+    },
+    serialize() {
+      return null;
+    },
+    deserialize(serialized) {
+      assertSerializedType(serialized === null, "undefined", "null");
+      return void 0;
+    },
+    isTerminal: true
+  },
+  bigint: {
+    condition(data) {
+      return typeof data === "bigint";
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string", "bigint", "a string");
+      return BigInt(serialized);
+    },
+    isTerminal: true
+  },
+  date: {
+    condition(data) {
+      return data instanceof Date;
+    },
+    serialize(data) {
+      if (Number.isNaN(data.getTime())) {
+        return null;
+      }
+      return data.toISOString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string" || serialized === null, "date", "a string or null");
+      return new Date(serialized ?? Number.NaN);
+    },
+    isTerminal: true
+  },
+  nan: {
+    condition(data) {
+      return typeof data === "number" && Number.isNaN(data);
+    },
+    serialize() {
+      return null;
+    },
+    deserialize(serialized) {
+      assertSerializedType(serialized === null, "nan", "null");
+      return Number.NaN;
+    },
+    isTerminal: true
+  },
+  url: {
+    condition(data) {
+      return data instanceof URL;
+    },
+    serialize(data) {
+      return data.toString();
+    },
+    deserialize(serialized) {
+      assertSerializedType(typeof serialized === "string", "url", "a string");
+      return new URL(serialized);
+    },
+    isTerminal: true
+  },
+  set: {
+    condition(data) {
+      return data instanceof Set;
+    },
+    serialize(data) {
+      return Array.from(data);
+    },
+    deserialize(serialized) {
+      assertSerializedType(Array.isArray(serialized), "set", "an array");
+      return new Set(serialized);
+    }
+  },
+  map: {
+    condition(data) {
+      return data instanceof Map;
+    },
+    serialize(data) {
+      return Array.from(data.entries());
+    },
+    deserialize(serialized) {
+      assertSerializedType(Array.isArray(serialized), "map", "an array");
+      return new Map(serialized);
+    }
+  }
+};
+class RPCJsonSerializer {
+  handlers;
+  inlineBuiltInHandlers;
+  handlerEntries;
+  omitUndefinedProperties;
+  constructor(options = {}) {
+    this.omitUndefinedProperties = options.omitUndefinedProperties !== false;
+    this.handlers = Object.assign(new NullProtoObj(), DEFAULT_RPC_JSON_SERIALIZER_HANDLERS);
+    const customHandlers = options.handlers;
+    if (customHandlers === void 0) {
+      this.inlineBuiltInHandlers = true;
+      return;
+    }
+    let inlineBuiltInHandlers = true;
+    let handlerEntries = [];
+    for (const key of Object.keys(customHandlers)) {
+      const handler = customHandlers[key];
+      this.handlers[key] = handler;
+      if (inlineBuiltInHandlers && key in DEFAULT_RPC_JSON_SERIALIZER_HANDLERS) {
+        inlineBuiltInHandlers = false;
+      }
+      if (inlineBuiltInHandlers && handler !== void 0) {
+        handlerEntries.push([key, handler]);
+      }
+    }
+    if (!inlineBuiltInHandlers) {
+      handlerEntries = [];
+      for (const key of Object.keys(this.handlers)) {
+        const handler = this.handlers[key];
+        if (handler !== void 0) {
+          handlerEntries.push([key, handler]);
+        }
+      }
+    }
+    this.inlineBuiltInHandlers = inlineBuiltInHandlers;
+    this.handlerEntries = handlerEntries;
+  }
+  serialize(data) {
+    let meta = [];
+    const maps = [];
+    const blobs = [];
+    const json = this.serializeValue(data, [], meta, maps, blobs);
+    meta = meta.length === 0 ? void 0 : meta;
+    if (maps.length === 0) {
+      return { json, meta };
+    }
+    return { json, meta, maps, blobs };
+  }
+  /**
+   * `segments` is a shared mutable stack (push/pop while walking),
+   * so it must be copied before being stored in `meta` or `maps`.
+   */
+  serializeValue(data, segments, meta, maps, blobs) {
+    if (this.inlineBuiltInHandlers) {
+      switch (typeof data) {
+        case "string":
+        case "boolean":
+          return data;
+        case "number":
+          if (Number.isNaN(data)) {
+            meta.push(["nan", ...segments]);
+            return null;
+          }
+          return data;
+        case "undefined":
+          meta.push(["undefined", ...segments]);
+          return null;
+        case "bigint":
+          meta.push(["bigint", ...segments]);
+          return data.toString();
+        case "object": {
+          if (data === null) {
+            return data;
+          }
+          if (data instanceof Date) {
+            meta.push(["date", ...segments]);
+            return Number.isNaN(data.getTime()) ? null : data.toISOString();
+          }
+          if (data instanceof URL) {
+            meta.push(["url", ...segments]);
+            return data.toString();
+          }
+          if (data instanceof Set) {
+            const result = this.serializeValue(Array.from(data), segments, meta, maps, blobs);
+            meta.push(["set", ...segments]);
+            return result;
+          }
+          if (data instanceof Map) {
+            const result = this.serializeValue(Array.from(data.entries()), segments, meta, maps, blobs);
+            meta.push(["map", ...segments]);
+            return result;
+          }
+        }
+      }
+    }
+    const handlerEntries = this.handlerEntries;
+    if (handlerEntries) {
+      for (let i = 0; i < handlerEntries.length; i++) {
+        const entry = handlerEntries[i];
+        const handler = entry[1];
+        if (handler.condition(data)) {
+          const serialized = handler.serialize(data);
+          if (handler.isTerminal) {
+            meta.push([entry[0], ...segments]);
+            if (serialized instanceof Blob) {
+              maps.push(segments.slice());
+              blobs.push(serialized);
+            }
+            return serialized;
+          }
+          const result = this.serializeValue(serialized, segments, meta, maps, blobs);
+          meta.push([entry[0], ...segments]);
+          return result;
+        }
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments.slice());
+      blobs.push(data);
+      return data;
+    }
+    if (Array.isArray(data)) {
+      const json = [];
+      for (let i = 0; i < data.length; i++) {
+        segments.push(i);
+        json.push(this.serializeValue(data[i], segments, meta, maps, blobs));
+        segments.pop();
+      }
+      return json;
+    }
+    if (isPlainObject(data)) {
+      const json = new NullProtoObj();
+      for (const k of Object.keys(data)) {
+        const v = data[k];
+        if (k === "toJSON" && typeof v === "function") {
+          continue;
+        }
+        if (v === void 0 && this.omitUndefinedProperties) {
+          continue;
+        }
+        segments.push(k);
+        json[k] = this.serializeValue(v, segments, meta, maps, blobs);
+        segments.pop();
+      }
+      return json;
+    }
+    return data;
+  }
+  deserialize(serialized) {
+    const ref = { json: serialized.json };
+    if (serialized.blobs?.length) {
+      for (let i = 0; i < serialized.maps.length; i++) {
+        const blob = serialized.blobs[i];
+        if (!(blob instanceof Blob)) {
+          throw invalidSerializedData(`blob ${i} is not a Blob.`);
+        }
+        const segments = serialized.maps[i];
+        let original = serialized;
+        let currentRef = ref;
+        let preSegment = "json";
+        for (let j = 0; j < segments.length; j++) {
+          original = original[preSegment];
+          currentRef = copyOnWrite(currentRef, preSegment, original);
+          preSegment = segments[j];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        }
+        currentRef[preSegment] = blob;
+      }
+    }
+    if (serialized.meta) {
+      for (const item of serialized.meta) {
+        const type = item[0];
+        const handler = this.handlers[type];
+        if (handler === void 0) {
+          throw invalidSerializedData(`type "${type}" is not supported.`);
+        }
+        let original = serialized;
+        let currentRef = ref;
+        let preSegment = "json";
+        for (let i = 1; i < item.length; i++) {
+          original = original[preSegment];
+          currentRef = copyOnWrite(currentRef, preSegment, original);
+          preSegment = item[i];
+          if (!Object.hasOwn(currentRef, preSegment)) {
+            throw invalidSerializedData(`segment "${preSegment}" does not exist.`);
+          }
+        }
+        currentRef[preSegment] = handler.deserialize(currentRef[preSegment]);
+      }
+    }
+    return ref.json;
+  }
+}
+
+class RPCSerializer {
+  jsonSerializer;
+  defaultSerializeOptions;
+  constructor(options = {}) {
+    this.jsonSerializer = new RPCJsonSerializer(options);
+    this.defaultSerializeOptions = options.serialize;
+  }
+  serialize(data, options = {}) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.serializeValue(result.value, false) };
+        },
+        mapError: (e) => new ErrorEvent(
+          this.serializeValue(toORPCError(e).toJSON(), false),
+          { cause: e }
+        )
+      });
+    }
+    const useFormDataForBlobs = options.useFormDataForBlobFields ?? this.defaultSerializeOptions?.useFormDataForBlobFields ?? true;
+    return this.serializeValue(data, useFormDataForBlobs);
+  }
+  serializeValue(data, useFormDataForBlobs) {
+    const { json, meta, maps, blobs } = this.jsonSerializer.serialize(data);
+    if (!useFormDataForBlobs || !blobs?.length) {
+      return { json, meta };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (data === void 0 || data instanceof ReadableStream || data instanceof Blob) {
+      return data;
+    }
+    if (isAsyncIteratorObject(data)) {
+      return wrapAsyncIteratorPreservingEventMeta(data, {
+        mapResult: (result) => {
+          if (result.value === void 0) {
+            return result;
+          }
+          return { done: result.done, value: this.deserializeValue(result.value) };
+        },
+        mapError: (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.deserializeValue(e.data);
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
+          }
+          return new ErrorEvent(deserialized, { cause: e });
+        }
+      });
+    }
+    return this.deserializeValue(data);
+  }
+  deserializeValue(data) {
+    if (!(data instanceof FormData)) {
+      return this.jsonSerializer.deserialize(data);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    const blobs = [];
+    for (const [key, value] of data) {
+      if (value instanceof Blob) {
+        blobs[Number(key)] = value;
+      }
+    }
+    return this.jsonSerializer.deserialize({ ...serialized, blobs });
+  }
+}
+
+export { RPCSerializer as R, createORPCErrorFromJson as a, isDefinedError as b, createORPCErrorFromMalformedResponse as c, RPCJsonSerializer as d, cloneORPCError as e, isORPCErrorJson as i, toORPCError as t, wrapAsyncIteratorPreservingEventMeta as w };

package/dist/shared/{client.CPF3hX6O.d.ts → client.BnpRXnLi.d.ts}

@@ -1,6 +1,6 @@
 import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.8ug8I-zu.js';
+import { StandardRequest, StandardLazyResponse } from '@standard-server/core';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.BoXZCzuS.js';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';

package/dist/shared/{client.8ug8I-zu.d.mts → client.BoXZCzuS.d.mts}

@@ -1,4 +1,5 @@
 import { PromiseWithError, Registry, MaybeOptionalOptions } from '@orpc/shared';
+import { StandardResponse } from '@standard-server/core';
 
 interface ClientContext {
     [key: PropertyKey]: any;
@@ -21,6 +22,11 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type AnyNestedClient = NestedClient<any>;
+/**
+ * Infers the **client context type** required by a client.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-context | Client-Side Clients - Infer Client Context}
+ */
 type InferClientContext<T extends AnyNestedClient> = T extends NestedClient<infer U> ? U : never;
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
@@ -29,6 +35,8 @@ interface ClientLink<TClientContext extends ClientContext> {
  * Recursively infers the **input types** from a client.
  *
  * Produces a nested map where each endpoint's input type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-inputs | Client-Side Clients - Infer Client Inputs}
  */
 type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientInputs<T[K]> : never;
@@ -38,6 +46,8 @@ type InferClientInputs<T extends AnyNestedClient> = T extends Client<any, infer
  *
  * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body input types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-inputs | Client-Side Clients - Infer Client Body Inputs}
  */
 type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, infer U, any, any> ? U extends {
     body: infer UBody;
@@ -48,6 +58,8 @@ type InferClientBodyInputs<T extends AnyNestedClient> = T extends Client<any, in
  * Recursively infers the **output types** from a client.
  *
  * Produces a nested map where each endpoint's output type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-outputs | Client-Side Clients - Infer Client Outputs}
  */
 type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientOutputs<T[K]> : never;
@@ -57,6 +69,8 @@ type InferClientOutputs<T extends AnyNestedClient> = T extends Client<any, any,
  *
  * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
  * Produces a nested map of body output types.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-body-outputs | Client-Side Clients - Infer Client Body Outputs}
  */
 type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, any, infer U, any> ? U extends {
     body: infer UBody;
@@ -64,22 +78,33 @@ type InferClientBodyOutputs<T extends AnyNestedClient> = T extends Client<any, a
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientBodyOutputs<T[K]> : never;
 };
 /**
- * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Produces a nested map where each endpoint's error type is preserved.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-errors | Client-Side Clients - Infer Client Errors}
  */
 type InferClientErrors<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientErrors<T[K]> : never;
 };
 /**
- * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#type‐safe-error-handling).
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.dev/docs/error-handling#typesafe-errors).
  *
  * Useful when you want to handle all possible errors from any endpoint at once.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side#infer-client-error | Client-Side Clients - Infer Client Error}
  */
 type InferClientError<T extends AnyNestedClient> = T extends Client<any, any, any, infer U> ? U : {
     [K in keyof T]: T[K] extends AnyNestedClient ? InferClientError<T[K]> : never;
 }[keyof T];
 
+/**
+ * Default mapping between common oRPC error codes and HTTP status codes.
+ * Handlers use it to determine response status codes; spread it to build a custom `errorStatusMap`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#custom-error-response | RPC Handler - Custom Error Response}
+ * @see {@link https://orpc.dev/docs/openapi/handler#custom-error-response | OpenAPI Handler - Custom Error Response}
+ */
 declare const COMMON_ERROR_STATUS_MAP: {
     BAD_REQUEST: number;
     UNAUTHORIZED: number;
@@ -114,24 +139,26 @@ type ORPCErrorOptions<TData> = ErrorOptions & {
 } : {
     data: TData;
 });
+/**
+ * Typed error carrying a `code`, a `message`, and optional `data`.
+ * Throw it from handlers or middleware to produce typed error responses on the client.
+ *
+ * @see {@link https://orpc.dev/docs/error-handling#orpcerror-class | Error Handling - ORPCError Class}
+ */
 declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     /**
-     * @info
-     * The `__branch` property is used for type branding, helping TypeScript distinguish
+     * @remarks
+     * **Note**: The `__branch` property is used for type branding, helping TypeScript distinguish
      * an `ORPCError` instance from plain objects with a similar structure.
      */
     readonly name: "ORPCError" & {
         __branch: "ORPCError";
     };
     /**
-     * Indicates whether the error matches a definition in the procedure's `.errors` map.
+     * Indicates whether the error matches a definition in the procedure's `.errors` map,
+     * which makes its type inferable on the client.
      */
     readonly defined: boolean;
-    /**
-     * Indicates whether the error's type is inferable at the TypeScript level.
-     * This is typically true when the error is explicitly defined or returned within a handler.
-     */
-    readonly inferable: boolean;
     code: TCode;
     data: TData;
     constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
@@ -155,13 +182,26 @@ interface ORPCErrorJSON<TCode extends string, TData> extends Pick<ORPCError<TCod
      * remove readonly
      */
     defined: boolean;
-    /**
-     * remove readonly
-     */
-    inferable: boolean;
 }
 type AnyORPCError = ORPCError<any, any>;
 type AnyORPCErrorJSON = ORPCErrorJSON<any, any>;
+interface MalformedResponseErrorOptions extends ErrorOptions {
+    message?: string;
+    response: StandardResponse;
+}
+/**
+ * Error indicating a response does not follow the expected oRPC format, carrying
+ * the resolved response. Found as the `cause` of a `MALFORMED_ORPC_RESPONSE`
+ * `ORPCError`.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare class MalformedResponseError extends Error {
+    readonly name = "MalformedResponseError";
+    response: StandardResponse;
+    constructor(options: MalformedResponseErrorOptions);
+}
 
-export { ORPCError as c, COMMON_ERROR_STATUS_MAP as j };
-export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, ORPCErrorJSON as d, AnyNestedClient as e, InferClientError as f, Client as g, ClientRest as h, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as p };
+export { ORPCError as h, COMMON_ERROR_STATUS_MAP as j, MalformedResponseError as p };
+export type { AnyORPCError as A, ClientContext as C, FriendlyClientOptions as F, InferClientContext as I, MalformedResponseErrorOptions as M, NestedClient as N, ORPCErrorCode as O, ClientOptions as a, ClientLink as b, AnyNestedClient as c, InferClientError as d, Client as e, ClientRest as f, ORPCErrorJSON as g, AnyORPCErrorJSON as i, InferClientBodyInputs as k, InferClientBodyOutputs as l, InferClientErrors as m, InferClientInputs as n, InferClientOutputs as o, ORPCErrorOptions as q };