@orpc/openapi-client 0.0.0-next.ea0903c → 0.0.0-next.eea495c

package/README.md

@@ -21,28 +21,24 @@
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
 
-**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
 
 ---
 
 ## Highlights
 
-- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
-- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
-- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
-- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
-- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
-- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
-- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
-- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
-- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
-- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
-- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
-- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
-- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
-- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
-- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -53,6 +49,7 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
 - [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
 - [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).

package/dist/adapters/fetch/index.d.mts

@@ -0,0 +1,22 @@
+import { ClientContext } from '@orpc/client';
+import { LinkFetchClientOptions } from '@orpc/client/fetch';
+import { AnyContractRouter } from '@orpc/contract';
+import { f as StandardOpenAPILinkOptions, g as StandardOpenAPILink } from '../../shared/openapi-client.D_hC2pAM.mjs';
+import '@orpc/client/standard';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+interface OpenAPILinkOptions<T extends ClientContext> extends StandardOpenAPILinkOptions<T>, LinkFetchClientOptions<T> {
+}
+/**
+ * The OpenAPI Link for fetch runtime communicates with the server that follow the OpenAPI specification.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
+ * @see {@link https://swagger.io/specification/ OpenAPI Specification}
+ */
+declare class OpenAPILink<T extends ClientContext> extends StandardOpenAPILink<T> {
+    constructor(contract: AnyContractRouter, options: OpenAPILinkOptions<T>);
+}
+
+export { OpenAPILink };
+export type { OpenAPILinkOptions };

package/dist/adapters/fetch/index.d.ts

@@ -0,0 +1,22 @@
+import { ClientContext } from '@orpc/client';
+import { LinkFetchClientOptions } from '@orpc/client/fetch';
+import { AnyContractRouter } from '@orpc/contract';
+import { f as StandardOpenAPILinkOptions, g as StandardOpenAPILink } from '../../shared/openapi-client.D_hC2pAM.js';
+import '@orpc/client/standard';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+interface OpenAPILinkOptions<T extends ClientContext> extends StandardOpenAPILinkOptions<T>, LinkFetchClientOptions<T> {
+}
+/**
+ * The OpenAPI Link for fetch runtime communicates with the server that follow the OpenAPI specification.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
+ * @see {@link https://swagger.io/specification/ OpenAPI Specification}
+ */
+declare class OpenAPILink<T extends ClientContext> extends StandardOpenAPILink<T> {
+    constructor(contract: AnyContractRouter, options: OpenAPILinkOptions<T>);
+}
+
+export { OpenAPILink };
+export type { OpenAPILinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,16 @@
+import { LinkFetchClient } from '@orpc/client/fetch';
+import '@orpc/shared';
+import { b as StandardOpenAPILink } from '../../shared/openapi-client.D89vdV2Y.mjs';
+import '@orpc/client';
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/standard-server';
+
+class OpenAPILink extends StandardOpenAPILink {
+  constructor(contract, options) {
+    const linkClient = new LinkFetchClient(options);
+    super(contract, linkClient, options);
+  }
+}
+
+export { OpenAPILink };

package/dist/adapters/standard/index.d.mts

@@ -1,38 +1,9 @@
-import { Segment } from '@orpc/shared';
+export { S as StandardBracketNotationSerialized, a as StandardBracketNotationSerializer, c as StandardOpenAPICustomJsonSerializer, b as StandardOpenAPIJsonSerialized, e as StandardOpenAPIJsonSerializer, d as StandardOpenAPIJsonSerializerOptions, g as StandardOpenAPILink, f as StandardOpenAPILinkOptions, j as StandardOpenAPISerializeOptions, k as StandardOpenAPISerializer, i as StandardOpenapiLinkCodec, h as StandardOpenapiLinkCodecOptions } from '../../shared/openapi-client.D_hC2pAM.mjs';
 import { HTTPPath } from '@orpc/client';
-
-type StandardBracketNotationSerialized = [string, unknown][];
-declare class StandardBracketNotationSerializer {
-    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
-    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
-    stringifyPath(segments: readonly Segment[]): string;
-    parsePath(path: string): string[];
-}
-
-type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
-interface StandardOpenAPICustomJsonSerializer {
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-}
-interface StandardOpenAPIJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
-}
-declare class StandardOpenAPIJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardOpenAPIJsonSerializerOptions);
-    serialize(data: unknown, hasBlobRef?: {
-        value: boolean;
-    }): StandardOpenAPIJsonSerialized;
-}
-
-declare class StandardOpenAPISerializer {
-    #private;
-    private readonly jsonSerializer;
-    private readonly bracketNotation;
-    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
 
 /**
  * @internal
@@ -46,4 +17,4 @@ declare function getDynamicParams(path: HTTPPath | undefined): {
     name: string;
 }[] | undefined;
 
-export { type StandardBracketNotationSerialized, StandardBracketNotationSerializer, type StandardOpenAPICustomJsonSerializer, type StandardOpenAPIJsonSerialized, StandardOpenAPIJsonSerializer, type StandardOpenAPIJsonSerializerOptions, StandardOpenAPISerializer, getDynamicParams, standardizeHTTPPath };
+export { getDynamicParams, standardizeHTTPPath };

package/dist/adapters/standard/index.d.ts

@@ -1,38 +1,9 @@
-import { Segment } from '@orpc/shared';
+export { S as StandardBracketNotationSerialized, a as StandardBracketNotationSerializer, c as StandardOpenAPICustomJsonSerializer, b as StandardOpenAPIJsonSerialized, e as StandardOpenAPIJsonSerializer, d as StandardOpenAPIJsonSerializerOptions, g as StandardOpenAPILink, f as StandardOpenAPILinkOptions, j as StandardOpenAPISerializeOptions, k as StandardOpenAPISerializer, i as StandardOpenapiLinkCodec, h as StandardOpenapiLinkCodecOptions } from '../../shared/openapi-client.D_hC2pAM.js';
 import { HTTPPath } from '@orpc/client';
-
-type StandardBracketNotationSerialized = [string, unknown][];
-declare class StandardBracketNotationSerializer {
-    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
-    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
-    stringifyPath(segments: readonly Segment[]): string;
-    parsePath(path: string): string[];
-}
-
-type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
-interface StandardOpenAPICustomJsonSerializer {
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-}
-interface StandardOpenAPIJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
-}
-declare class StandardOpenAPIJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardOpenAPIJsonSerializerOptions);
-    serialize(data: unknown, hasBlobRef?: {
-        value: boolean;
-    }): StandardOpenAPIJsonSerialized;
-}
-
-declare class StandardOpenAPISerializer {
-    #private;
-    private readonly jsonSerializer;
-    private readonly bracketNotation;
-    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
+import '@orpc/client/standard';
+import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
 
 /**
  * @internal
@@ -46,4 +17,4 @@ declare function getDynamicParams(path: HTTPPath | undefined): {
     name: string;
 }[] | undefined;
 
-export { type StandardBracketNotationSerialized, StandardBracketNotationSerializer, type StandardOpenAPICustomJsonSerializer, type StandardOpenAPIJsonSerialized, StandardOpenAPIJsonSerializer, type StandardOpenAPIJsonSerializerOptions, StandardOpenAPISerializer, getDynamicParams, standardizeHTTPPath };
+export { getDynamicParams, standardizeHTTPPath };

package/dist/adapters/standard/index.mjs

@@ -1,239 +1,6 @@
-import { isObject, isAsyncIteratorObject } from '@orpc/shared';
-import { mapEventIterator, toORPCError, ORPCError } from '@orpc/client';
-import { ErrorEvent } from '@orpc/standard-server';
-
-class StandardBracketNotationSerializer {
-  serialize(data, segments = [], result = []) {
-    if (Array.isArray(data)) {
-      data.forEach((item, i) => {
-        this.serialize(item, [...segments, i], result);
-      });
-    } else if (isObject(data)) {
-      for (const key in data) {
-        this.serialize(data[key], [...segments, key], result);
-      }
-    } else {
-      result.push([this.stringifyPath(segments), data]);
-    }
-    return result;
-  }
-  deserialize(serialized) {
-    if (serialized.length === 0) {
-      return {};
-    }
-    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
-    const ref = { value: [] };
-    for (const [path, value] of serialized) {
-      const segments = this.parsePath(path);
-      let currentRef = ref;
-      let nextSegment = "value";
-      segments.forEach((segment, i) => {
-        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
-          currentRef[nextSegment] = [];
-        }
-        if (i !== segments.length - 1) {
-          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
-            currentRef[nextSegment] = { ...currentRef[nextSegment] };
-          }
-        } else {
-          if (Array.isArray(currentRef[nextSegment])) {
-            if (segment === "") {
-              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            } else {
-              if (arrayPushStyles.has(currentRef[nextSegment])) {
-                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
-              } else if (!isValidArrayIndex(segment)) {
-                currentRef[nextSegment] = { ...currentRef[nextSegment] };
-              }
-            }
-          }
-        }
-        currentRef = currentRef[nextSegment];
-        nextSegment = segment;
-      });
-      if (Array.isArray(currentRef)) {
-        if (nextSegment === "") {
-          arrayPushStyles.add(currentRef);
-          currentRef.push(value);
-        } else {
-          currentRef[Number(nextSegment)] = value;
-        }
-      } else {
-        currentRef[nextSegment] = value;
-      }
-    }
-    return ref.value;
-  }
-  stringifyPath(segments) {
-    return segments.map((segment) => {
-      return segment.toString().replace(/[\\[\]]/g, (match) => {
-        switch (match) {
-          case "\\":
-            return "\\\\";
-          case "[":
-            return "\\[";
-          case "]":
-            return "\\]";
-          /* v8 ignore next 2 */
-          default:
-            return match;
-        }
-      });
-    }).reduce((result, segment, i) => {
-      if (i === 0) {
-        return segment;
-      }
-      return `${result}[${segment}]`;
-    }, "");
-  }
-  parsePath(path) {
-    const segments = [];
-    let inBrackets = false;
-    let currentSegment = "";
-    let backslashCount = 0;
-    for (let i = 0; i < path.length; i++) {
-      const char = path[i];
-      const nextChar = path[i + 1];
-      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
-        if (nextChar === void 0) {
-          inBrackets = false;
-        }
-        segments.push(currentSegment);
-        currentSegment = "";
-        i++;
-      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
-        inBrackets = true;
-        segments.push(currentSegment);
-        currentSegment = "";
-      } else if (char === "\\") {
-        backslashCount++;
-      } else {
-        currentSegment += "\\".repeat(backslashCount / 2) + char;
-        backslashCount = 0;
-      }
-    }
-    return inBrackets || segments.length === 0 ? [path] : segments;
-  }
-}
-function isValidArrayIndex(value) {
-  return /^0$|^[1-9]\d*$/.test(value);
-}
-
-class StandardOpenAPIJsonSerializer {
-  customSerializers;
-  constructor(options = {}) {
-    this.customSerializers = options.customJsonSerializers ?? [];
-  }
-  serialize(data, hasBlobRef = { value: false }) {
-    for (const custom of this.customSerializers) {
-      if (custom.condition(data)) {
-        const result = this.serialize(custom.serialize(data), hasBlobRef);
-        return result;
-      }
-    }
-    if (data instanceof Blob) {
-      hasBlobRef.value = true;
-      return [data, hasBlobRef.value];
-    }
-    if (data instanceof Set) {
-      return this.serialize(Array.from(data), hasBlobRef);
-    }
-    if (data instanceof Map) {
-      return this.serialize(Array.from(data.entries()), hasBlobRef);
-    }
-    if (Array.isArray(data)) {
-      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
-      return [json, hasBlobRef.value];
-    }
-    if (isObject(data)) {
-      const json = {};
-      for (const k in data) {
-        if (k === "toJSON" && typeof data[k] === "function") {
-          continue;
-        }
-        json[k] = this.serialize(data[k], hasBlobRef)[0];
-      }
-      return [json, hasBlobRef.value];
-    }
-    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
-      return [data.toString(), hasBlobRef.value];
-    }
-    if (data instanceof Date) {
-      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
-    }
-    if (Number.isNaN(data)) {
-      return [null, hasBlobRef.value];
-    }
-    return [data, hasBlobRef.value];
-  }
-}
-
-class StandardOpenAPISerializer {
-  constructor(jsonSerializer, bracketNotation) {
-    this.jsonSerializer = jsonSerializer;
-    this.bracketNotation = bracketNotation;
-  }
-  serialize(data) {
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => this.#serialize(value, false),
-        error: async (e) => {
-          return new ErrorEvent({
-            data: this.#serialize(toORPCError(e).toJSON(), false),
-            cause: e
-          });
-        }
-      });
-    }
-    return this.#serialize(data, true);
-  }
-  #serialize(data, enableFormData) {
-    if (data instanceof Blob || data === void 0) {
-      return data;
-    }
-    const [json, hasBlob] = this.jsonSerializer.serialize(data);
-    if (!enableFormData || !hasBlob) {
-      return json;
-    }
-    const form = new FormData();
-    for (const [path, value] of this.bracketNotation.serialize(json)) {
-      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        form.append(path, value.toString());
-      } else if (value instanceof Blob) {
-        form.append(path, value);
-      }
-    }
-    return form;
-  }
-  deserialize(data) {
-    if (data instanceof URLSearchParams || data instanceof FormData) {
-      return this.bracketNotation.deserialize(Array.from(data.entries()));
-    }
-    if (isAsyncIteratorObject(data)) {
-      return mapEventIterator(data, {
-        value: async (value) => value,
-        error: async (e) => {
-          if (e instanceof ErrorEvent && ORPCError.isValidJSON(e.data)) {
-            return ORPCError.fromJSON(e.data, { cause: e });
-          }
-          return e;
-        }
-      });
-    }
-    return data;
-  }
-}
-
-function standardizeHTTPPath(path) {
-  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
-}
-function getDynamicParams(path) {
-  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
-    raw: v,
-    name: v.match(/\{\+?([^}]+)\}/)[1]
-  })) : void 0;
-}
-
-export { StandardBracketNotationSerializer, StandardOpenAPIJsonSerializer, StandardOpenAPISerializer, getDynamicParams, standardizeHTTPPath };
+export { S as StandardBracketNotationSerializer, a as StandardOpenAPIJsonSerializer, b as StandardOpenAPILink, d as StandardOpenAPISerializer, c as StandardOpenapiLinkCodec, g as getDynamicParams, s as standardizeHTTPPath } from '../../shared/openapi-client.D89vdV2Y.mjs';
+import '@orpc/client/standard';
+import '@orpc/shared';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';

package/dist/index.d.mts

@@ -1,2 +1,16 @@
+import { NestedClient, Client, ORPCError } from '@orpc/client';
 
-export {  }
+type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: JsonifiedValue<T[K]>;
+} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
+type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [U extends undefined ? null : JsonifiedValue<U>, ...JsonifiedArray<V>] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
+/**
+ * Convert types that JSON not support to corresponding json types
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
+ */
+type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
+};
+
+export type { JsonifiedArray, JsonifiedClient, JsonifiedValue };

package/dist/index.d.ts

@@ -1,2 +1,16 @@
+import { NestedClient, Client, ORPCError } from '@orpc/client';
 
-export {  }
+type JsonifiedValue<T> = T extends string ? T : T extends number ? T : T extends boolean ? T : T extends null ? T : T extends undefined ? T : T extends Array<unknown> ? JsonifiedArray<T> : T extends Record<string, unknown> ? {
+    [K in keyof T]: JsonifiedValue<T[K]>;
+} : T extends Date ? string : T extends bigint ? string : T extends File ? File : T extends Blob ? Blob : T extends RegExp ? string : T extends URL ? string : T extends Map<infer K, infer V> ? JsonifiedArray<[K, V][]> : T extends Set<infer U> ? JsonifiedArray<U[]> : T extends AsyncIteratorObject<infer U, infer V> ? AsyncIteratorObject<JsonifiedValue<U>, JsonifiedValue<V>> : unknown;
+type JsonifiedArray<T extends Array<unknown>> = T extends readonly [] ? [] : T extends readonly [infer U, ...infer V] ? [U extends undefined ? null : JsonifiedValue<U>, ...JsonifiedArray<V>] : T extends Array<infer U> ? Array<JsonifiedValue<U>> : unknown;
+/**
+ * Convert types that JSON not support to corresponding json types
+ *
+ * @see {@link https://orpc.unnoq.com/docs/openapi/client/openapi-link OpenAPI Link Docs}
+ */
+type JsonifiedClient<T extends NestedClient<any>> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? Client<UClientContext, UInput, JsonifiedValue<UOutput>, UError extends ORPCError<infer UCode, infer UData> ? ORPCError<UCode, JsonifiedValue<UData>> : UError> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? JsonifiedClient<T[K]> : T[K];
+};
+
+export type { JsonifiedArray, JsonifiedClient, JsonifiedValue };

package/dist/shared/openapi-client.D89vdV2Y.mjs

@@ -0,0 +1,413 @@
+import { toHttpPath, getMalformedResponseErrorCode, StandardLink } from '@orpc/client/standard';
+import { isObject, value, get, isAsyncIteratorObject } from '@orpc/shared';
+import { isORPCErrorStatus, isORPCErrorJson, createORPCErrorFromJson, mapEventIterator, toORPCError } from '@orpc/client';
+import { isContractProcedure, fallbackContractConfig, ORPCError } from '@orpc/contract';
+import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
+
+class StandardBracketNotationSerializer {
+  serialize(data, segments = [], result = []) {
+    if (Array.isArray(data)) {
+      data.forEach((item, i) => {
+        this.serialize(item, [...segments, i], result);
+      });
+    } else if (isObject(data)) {
+      for (const key in data) {
+        this.serialize(data[key], [...segments, key], result);
+      }
+    } else {
+      result.push([this.stringifyPath(segments), data]);
+    }
+    return result;
+  }
+  deserialize(serialized) {
+    if (serialized.length === 0) {
+      return {};
+    }
+    const arrayPushStyles = /* @__PURE__ */ new WeakSet();
+    const ref = { value: [] };
+    for (const [path, value] of serialized) {
+      const segments = this.parsePath(path);
+      let currentRef = ref;
+      let nextSegment = "value";
+      segments.forEach((segment, i) => {
+        if (!Array.isArray(currentRef[nextSegment]) && !isObject(currentRef[nextSegment])) {
+          currentRef[nextSegment] = [];
+        }
+        if (i !== segments.length - 1) {
+          if (Array.isArray(currentRef[nextSegment]) && !isValidArrayIndex(segment)) {
+            currentRef[nextSegment] = { ...currentRef[nextSegment] };
+          }
+        } else {
+          if (Array.isArray(currentRef[nextSegment])) {
+            if (segment === "") {
+              if (currentRef[nextSegment].length && !arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            } else {
+              if (arrayPushStyles.has(currentRef[nextSegment])) {
+                currentRef[nextSegment] = { "": currentRef[nextSegment].at(-1) };
+              } else if (!isValidArrayIndex(segment)) {
+                currentRef[nextSegment] = { ...currentRef[nextSegment] };
+              }
+            }
+          }
+        }
+        currentRef = currentRef[nextSegment];
+        nextSegment = segment;
+      });
+      if (Array.isArray(currentRef)) {
+        if (nextSegment === "") {
+          arrayPushStyles.add(currentRef);
+          currentRef.push(value);
+        } else {
+          currentRef[Number(nextSegment)] = value;
+        }
+      } else {
+        currentRef[nextSegment] = value;
+      }
+    }
+    return ref.value;
+  }
+  stringifyPath(segments) {
+    return segments.map((segment) => {
+      return segment.toString().replace(/[\\[\]]/g, (match) => {
+        switch (match) {
+          case "\\":
+            return "\\\\";
+          case "[":
+            return "\\[";
+          case "]":
+            return "\\]";
+          /* v8 ignore next 2 */
+          default:
+            return match;
+        }
+      });
+    }).reduce((result, segment, i) => {
+      if (i === 0) {
+        return segment;
+      }
+      return `${result}[${segment}]`;
+    }, "");
+  }
+  parsePath(path) {
+    const segments = [];
+    let inBrackets = false;
+    let currentSegment = "";
+    let backslashCount = 0;
+    for (let i = 0; i < path.length; i++) {
+      const char = path[i];
+      const nextChar = path[i + 1];
+      if (inBrackets && char === "]" && (nextChar === void 0 || nextChar === "[") && backslashCount % 2 === 0) {
+        if (nextChar === void 0) {
+          inBrackets = false;
+        }
+        segments.push(currentSegment);
+        currentSegment = "";
+        i++;
+      } else if (segments.length === 0 && char === "[" && backslashCount % 2 === 0) {
+        inBrackets = true;
+        segments.push(currentSegment);
+        currentSegment = "";
+      } else if (char === "\\") {
+        backslashCount++;
+      } else {
+        currentSegment += "\\".repeat(backslashCount / 2) + char;
+        backslashCount = 0;
+      }
+    }
+    return inBrackets || segments.length === 0 ? [path] : segments;
+  }
+}
+function isValidArrayIndex(value) {
+  return /^0$|^[1-9]\d*$/.test(value);
+}
+
+class StandardOpenAPIJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+  }
+  serialize(data, hasBlobRef = { value: false }) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), hasBlobRef);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      hasBlobRef.value = true;
+      return [data, hasBlobRef.value];
+    }
+    if (data instanceof Set) {
+      return this.serialize(Array.from(data), hasBlobRef);
+    }
+    if (data instanceof Map) {
+      return this.serialize(Array.from(data.entries()), hasBlobRef);
+    }
+    if (Array.isArray(data)) {
+      const json = data.map((v) => v === void 0 ? null : this.serialize(v, hasBlobRef)[0]);
+      return [json, hasBlobRef.value];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
+        json[k] = this.serialize(data[k], hasBlobRef)[0];
+      }
+      return [json, hasBlobRef.value];
+    }
+    if (typeof data === "bigint" || data instanceof RegExp || data instanceof URL) {
+      return [data.toString(), hasBlobRef.value];
+    }
+    if (data instanceof Date) {
+      return [Number.isNaN(data.getTime()) ? null : data.toISOString(), hasBlobRef.value];
+    }
+    if (Number.isNaN(data)) {
+      return [null, hasBlobRef.value];
+    }
+    return [data, hasBlobRef.value];
+  }
+}
+
+function standardizeHTTPPath(path) {
+  return `/${path.replace(/\/{2,}/g, "/").replace(/^\/|\/$/g, "")}`;
+}
+function getDynamicParams(path) {
+  return path ? standardizeHTTPPath(path).match(/\/\{[^}]+\}/g)?.map((v) => ({
+    raw: v,
+    name: v.match(/\{\+?([^}]+)\}/)[1]
+  })) : void 0;
+}
+
+class StandardOpenapiLinkCodec {
+  constructor(contract, serializer, options) {
+    this.contract = contract;
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  headers;
+  async encode(path, input, options) {
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    let headers = await value(this.headers, options, path, input);
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
+    const procedure = get(this.contract, path);
+    if (!isContractProcedure(procedure)) {
+      throw new Error(`[StandardOpenapiLinkCodec] expect a contract procedure at ${path.join(".")}`);
+    }
+    const inputStructure = fallbackContractConfig("defaultInputStructure", procedure["~orpc"].route.inputStructure);
+    return inputStructure === "compact" ? this.#encodeCompact(procedure, path, input, options, baseUrl, headers) : this.#encodeDetailed(procedure, path, input, options, baseUrl, headers);
+  }
+  #encodeCompact(procedure, path, input, options, baseUrl, headers) {
+    let httpPath = standardizeHTTPPath(procedure["~orpc"].route.path ?? toHttpPath(path));
+    let httpBody = input;
+    const dynamicParams = getDynamicParams(httpPath);
+    if (dynamicParams?.length) {
+      if (!isObject(input)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input shape for "compact" structure when has dynamic params at ${path.join(".")}.`);
+      }
+      const body = { ...input };
+      for (const param of dynamicParams) {
+        const value2 = input[param.name];
+        httpPath = httpPath.replace(param.raw, `/${encodeURIComponent(`${this.serializer.serialize(value2)}`)}`);
+        delete body[param.name];
+      }
+      httpBody = Object.keys(body).length ? body : void 0;
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${httpPath}`;
+    if (method === "GET") {
+      const serialized = this.serializer.serialize(httpBody, { outputFormat: "URLSearchParams" });
+      for (const [key, value2] of serialized) {
+        url.searchParams.append(key, value2);
+      }
+      return {
+        url,
+        method,
+        headers,
+        body: void 0,
+        signal: options.signal
+      };
+    }
+    return {
+      url,
+      method,
+      headers,
+      body: this.serializer.serialize(httpBody),
+      signal: options.signal
+    };
+  }
+  #encodeDetailed(procedure, path, input, options, baseUrl, headers) {
+    let httpPath = standardizeHTTPPath(procedure["~orpc"].route.path ?? toHttpPath(path));
+    const dynamicParams = getDynamicParams(httpPath);
+    if (!isObject(input) && input !== void 0) {
+      throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input shape for "detailed" structure at ${path.join(".")}.`);
+    }
+    if (dynamicParams?.length) {
+      if (!isObject(input?.params)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input.params shape for "detailed" structure when has dynamic params at ${path.join(".")}.`);
+      }
+      for (const param of dynamicParams) {
+        const value2 = input.params[param.name];
+        httpPath = httpPath.replace(param.raw, `/${encodeURIComponent(`${this.serializer.serialize(value2)}`)}`);
+      }
+    }
+    let mergedHeaders = headers;
+    if (input?.headers !== void 0) {
+      if (!isObject(input.headers)) {
+        throw new TypeError(`[StandardOpenapiLinkCodec] Invalid input.headers shape for "detailed" structure at ${path.join(".")}.`);
+      }
+      mergedHeaders = mergeStandardHeaders(input.headers, headers);
+    }
+    const method = fallbackContractConfig("defaultMethod", procedure["~orpc"].route.method);
+    const url = new URL(baseUrl);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${httpPath}`;
+    if (input?.query !== void 0) {
+      const query = this.serializer.serialize(input.query, { outputFormat: "URLSearchParams" });
+      for (const [key, value2] of query) {
+        url.searchParams.append(key, value2);
+      }
+    }
+    if (method === "GET") {
+      return {
+        url,
+        method,
+        headers: mergedHeaders,
+        body: void 0,
+        signal: options.signal
+      };
+    }
+    return {
+      url,
+      method,
+      headers: mergedHeaders,
+      body: this.serializer.serialize(input?.body),
+      signal: options.signal
+    };
+  }
+  async decode(response, _options, path) {
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid OpenAPI response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    const procedure = get(this.contract, path);
+    if (!isContractProcedure(procedure)) {
+      throw new Error(`[StandardOpenapiLinkCodec] expect a contract procedure at ${path.join(".")}`);
+    }
+    const outputStructure = fallbackContractConfig("defaultOutputStructure", procedure["~orpc"].route.outputStructure);
+    if (outputStructure === "compact") {
+      return deserialized;
+    }
+    return {
+      headers: response.headers,
+      body: deserialized
+    };
+  }
+}
+
+class StandardOpenAPISerializer {
+  constructor(jsonSerializer, bracketNotation) {
+    this.jsonSerializer = jsonSerializer;
+    this.bracketNotation = bracketNotation;
+  }
+  serialize(data, options = {}) {
+    if (isAsyncIteratorObject(data) && !options.outputFormat) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, { outputFormat: "plain" }),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), { outputFormat: "plain" }),
+            cause: e
+          });
+        }
+      });
+    }
+    return this.#serialize(data, options);
+  }
+  #serialize(data, options) {
+    const [json, hasBlob] = this.jsonSerializer.serialize(data);
+    if (options.outputFormat === "plain") {
+      return json;
+    }
+    if (options.outputFormat === "URLSearchParams") {
+      const params = new URLSearchParams();
+      for (const [path, value] of this.bracketNotation.serialize(json)) {
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+          params.append(path, value.toString());
+        }
+      }
+      return params;
+    }
+    if (json instanceof Blob || json === void 0 || !hasBlob) {
+      return json;
+    }
+    const form = new FormData();
+    for (const [path, value] of this.bracketNotation.serialize(json)) {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        form.append(path, value.toString());
+      } else if (value instanceof Blob) {
+        form.append(path, value);
+      }
+    }
+    return form;
+  }
+  deserialize(data) {
+    if (data instanceof URLSearchParams || data instanceof FormData) {
+      return this.bracketNotation.deserialize(Array.from(data.entries()));
+    }
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => value,
+        error: async (e) => {
+          if (e instanceof ErrorEvent && isORPCErrorJson(e.data)) {
+            return createORPCErrorFromJson(e.data, { cause: e });
+          }
+          return e;
+        }
+      });
+    }
+    return data;
+  }
+}
+
+class StandardOpenAPILink extends StandardLink {
+  constructor(contract, linkClient, options) {
+    const jsonSerializer = new StandardOpenAPIJsonSerializer(options);
+    const bracketNotationSerializer = new StandardBracketNotationSerializer();
+    const serializer = new StandardOpenAPISerializer(jsonSerializer, bracketNotationSerializer);
+    const linkCodec = new StandardOpenapiLinkCodec(contract, serializer, options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+export { StandardBracketNotationSerializer as S, StandardOpenAPIJsonSerializer as a, StandardOpenAPILink as b, StandardOpenapiLinkCodec as c, StandardOpenAPISerializer as d, getDynamicParams as g, standardizeHTTPPath as s };

package/dist/shared/openapi-client.D_hC2pAM.d.mts

@@ -0,0 +1,79 @@
+import { ClientContext, ClientOptions } from '@orpc/client';
+import { StandardLinkCodec, StandardLinkOptions, StandardLink, StandardLinkClient } from '@orpc/client/standard';
+import { AnyContractRouter } from '@orpc/contract';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+type StandardBracketNotationSerialized = [string, unknown][];
+declare class StandardBracketNotationSerializer {
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
+
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+interface StandardOpenAPICustomJsonSerializer {
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+}
+interface StandardOpenAPIJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
+}
+declare class StandardOpenAPIJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardOpenAPIJsonSerializerOptions);
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardOpenapiLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardOpenapiLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    #private;
+    private readonly contract;
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(contract: AnyContractRouter, serializer: StandardOpenAPISerializer, options: StandardOpenapiLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, _options: ClientOptions<T>, path: readonly string[]): Promise<unknown>;
+}
+
+interface StandardOpenAPILinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardOpenapiLinkCodecOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+declare class StandardOpenAPILink<T extends ClientContext> extends StandardLink<T> {
+    constructor(contract: AnyContractRouter, linkClient: StandardLinkClient<T>, options: StandardOpenAPILinkOptions<T>);
+}
+
+export { StandardBracketNotationSerializer as a, StandardOpenAPIJsonSerializer as e, StandardOpenAPILink as g, StandardOpenapiLinkCodec as i, StandardOpenAPISerializer as k };
+export type { StandardBracketNotationSerialized as S, StandardOpenAPIJsonSerialized as b, StandardOpenAPICustomJsonSerializer as c, StandardOpenAPIJsonSerializerOptions as d, StandardOpenAPILinkOptions as f, StandardOpenapiLinkCodecOptions as h, StandardOpenAPISerializeOptions as j };

package/dist/shared/openapi-client.D_hC2pAM.d.ts

@@ -0,0 +1,79 @@
+import { ClientContext, ClientOptions } from '@orpc/client';
+import { StandardLinkCodec, StandardLinkOptions, StandardLink, StandardLinkClient } from '@orpc/client/standard';
+import { AnyContractRouter } from '@orpc/contract';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+type StandardBracketNotationSerialized = [string, unknown][];
+declare class StandardBracketNotationSerializer {
+    serialize(data: unknown, segments?: Segment[], result?: StandardBracketNotationSerialized): StandardBracketNotationSerialized;
+    deserialize(serialized: StandardBracketNotationSerialized): Record<string, unknown> | unknown[];
+    stringifyPath(segments: readonly Segment[]): string;
+    parsePath(path: string): string[];
+}
+
+type StandardOpenAPIJsonSerialized = [json: unknown, hasBlob: boolean];
+interface StandardOpenAPICustomJsonSerializer {
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+}
+interface StandardOpenAPIJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardOpenAPICustomJsonSerializer[];
+}
+declare class StandardOpenAPIJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardOpenAPIJsonSerializerOptions);
+    serialize(data: unknown, hasBlobRef?: {
+        value: boolean;
+    }): StandardOpenAPIJsonSerialized;
+}
+
+interface StandardOpenAPISerializeOptions {
+    outputFormat?: 'plain' | 'URLSearchParams';
+}
+declare class StandardOpenAPISerializer {
+    #private;
+    private readonly jsonSerializer;
+    private readonly bracketNotation;
+    constructor(jsonSerializer: StandardOpenAPIJsonSerializer, bracketNotation: StandardBracketNotationSerializer);
+    serialize(data: unknown, options?: StandardOpenAPISerializeOptions): unknown;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardOpenapiLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardOpenapiLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    #private;
+    private readonly contract;
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(contract: AnyContractRouter, serializer: StandardOpenAPISerializer, options: StandardOpenapiLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, _options: ClientOptions<T>, path: readonly string[]): Promise<unknown>;
+}
+
+interface StandardOpenAPILinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardOpenapiLinkCodecOptions<T>, StandardOpenAPIJsonSerializerOptions {
+}
+declare class StandardOpenAPILink<T extends ClientContext> extends StandardLink<T> {
+    constructor(contract: AnyContractRouter, linkClient: StandardLinkClient<T>, options: StandardOpenAPILinkOptions<T>);
+}
+
+export { StandardBracketNotationSerializer as a, StandardOpenAPIJsonSerializer as e, StandardOpenAPILink as g, StandardOpenapiLinkCodec as i, StandardOpenAPISerializer as k };
+export type { StandardBracketNotationSerialized as S, StandardOpenAPIJsonSerialized as b, StandardOpenAPICustomJsonSerializer as c, StandardOpenAPIJsonSerializerOptions as d, StandardOpenAPILinkOptions as f, StandardOpenapiLinkCodecOptions as h, StandardOpenAPISerializeOptions as j };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/openapi-client",
   "type": "module",
-  "version": "0.0.0-next.ea0903c",
+  "version": "0.0.0-next.eea495c",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -23,15 +23,24 @@
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
       "default": "./dist/adapters/standard/index.mjs"
+    },
+    "./fetch": {
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@orpc/client": "0.0.0-next.ea0903c",
-    "@orpc/shared": "0.0.0-next.ea0903c",
-    "@orpc/standard-server": "0.0.0-next.ea0903c"
+    "@orpc/client": "0.0.0-next.eea495c",
+    "@orpc/contract": "0.0.0-next.eea495c",
+    "@orpc/shared": "0.0.0-next.eea495c",
+    "@orpc/standard-server": "0.0.0-next.eea495c"
+  },
+  "devDependencies": {
+    "@orpc/server": "0.0.0-next.eea495c"
   },
   "scripts": {
     "build": "unbuild",