@orpc/client 0.0.0-next.d888fab → 0.0.0-next.d8deda3

package/dist/plugins/index.d.ts

@@ -1,7 +1,8 @@
-import { Value } from '@orpc/shared';
-import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.7ZYxJok_.js';
-import { a as ClientContext } from '../shared/client.4TS_0JaO.js';
+import { Value, Promisable } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { BatchResponseMode } from '@orpc/standard-server/batch';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.De8SW4Kw.js';
+import { b as ClientContext } from '../shared/client.BH1AYT_p.js';
 
 interface BatchLinkPluginGroup<T extends ClientContext> {
     condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
@@ -16,25 +17,31 @@ interface BatchLinkPluginOptions<T extends ClientContext> {
      *
      * @default 10
      */
-    maxSize?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    maxSize?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    /**
+     * The batch response mode.
+     *
+     * @default 'streaming'
+     */
+    mode?: Value<BatchResponseMode, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
      * Defines the URL to use for the batch request.
      *
      * @default the URL of the first request in the batch + '/__batch__'
      */
-    url?: Value<string | URL, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    url?: Value<Promisable<string | URL>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
      * The maximum length of the URL.
      *
      * @default 2083
      */
-    maxUrlLength?: Value<number, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    maxUrlLength?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
      * Defines the HTTP headers to use for the batch request.
      *
      * @default The same headers of all requests in the batch
      */
-    headers?: Value<StandardHeaders, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    headers?: Value<Promisable<StandardHeaders>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
     /**
      * Map the batch request items before sending them.
      *
@@ -52,10 +59,10 @@ interface BatchLinkPluginOptions<T extends ClientContext> {
     exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
 }
 /**
- * The Batch Request/Response Plugin allows you to combine multiple requests and responses into a single batch,
+ * The Batch Requests Plugin allows you to combine multiple requests and responses into a single batch,
  * reducing the overhead of sending each one separately.
  *
- * @see {@link https://orpc.unnoq.com/docs/plugins/batch-request-response Batch Request/Response Plugin Docs}
+ * @see {@link https://orpc.unnoq.com/docs/plugins/batch-requests Batch Requests Plugin Docs}
  */
 declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
     #private;
@@ -66,12 +73,45 @@ declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPl
     private readonly batchHeaders;
     private readonly mapRequestItem;
     private readonly exclude;
+    private readonly mode;
     private pending;
     order: number;
     constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
     init(options: StandardLinkOptions<T>): void;
 }
 
+interface DedupeRequestsPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    /**
+     * The context used for the rest of the request lifecycle.
+     */
+    context: T;
+}
+interface DedupeRequestsPluginOptions<T extends ClientContext> {
+    /**
+     * To enable deduplication, a request must match at least one defined group.
+     * Requests that fall into the same group are considered for deduplication together.
+     */
+    groups: readonly [DedupeRequestsPluginGroup<T>, ...DedupeRequestsPluginGroup<T>[]];
+    /**
+     * Filters requests to dedupe
+     *
+     * @default (({ request }) => request.method === 'GET')
+     */
+    filter?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+}
+/**
+ * Prevents duplicate requests by deduplicating similar ones to reduce server load.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/dedupe-requests Dedupe Requests Plugin}
+ */
+declare class DedupeRequestsPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    order: number;
+    constructor(options: NoInfer<DedupeRequestsPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): void;
+}
+
 interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
     lastEventRetry: number | undefined;
     attemptIndex: number;
@@ -84,19 +124,19 @@ interface ClientRetryPluginContext {
      *
      * @default 0
      */
-    retry?: Value<number, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    retry?: Value<Promisable<number>, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
     /**
      * Delay (in ms) before retrying.
      *
      * @default (o) => o.lastEventRetry ?? 2000
      */
-    retryDelay?: Value<number, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    retryDelay?: Value<Promisable<number>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
     /**
      * Determine should retry or not.
      *
      * @default true
      */
-    shouldRetry?: Value<boolean, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    shouldRetry?: Value<Promisable<boolean>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
     /**
      * The hook called when retrying, and return the unsubscribe function.
      */
@@ -117,30 +157,77 @@ declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements S
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
     private readonly defaultOnRetry;
+    order: number;
     constructor(options?: ClientRetryPluginOptions);
     init(options: StandardLinkOptions<T>): void;
 }
 
+interface RetryAfterPluginOptions<T extends ClientContext> {
+    /**
+     * Override condition to determine whether to retry or not.
+     *
+     * @default ((response) => response.status === 429 || response.status === 503)
+     */
+    condition?: Value<boolean, [
+        response: StandardLazyResponse,
+        options: StandardLinkClientInterceptorOptions<T>
+    ]>;
+    /**
+     * Maximum attempts before giving up retries.
+     *
+     * @default 3
+     */
+    maxAttempts?: Value<number, [
+        response: StandardLazyResponse,
+        options: StandardLinkClientInterceptorOptions<T>
+    ]>;
+    /**
+     * Maximum timeout in milliseconds to wait before giving up retries.
+     *
+     * @default 5 * 60 * 1000 (5 minutes)
+     */
+    timeout?: Value<number, [
+        response: StandardLazyResponse,
+        options: StandardLinkClientInterceptorOptions<T>
+    ]>;
+}
+/**
+ * The Retry After Plugin automatically retries requests based on server `Retry-After` headers.
+ * This is particularly useful for handling rate limiting and temporary server unavailability.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/plugins/retry-after Retry After Plugin Docs}
+ */
+declare class RetryAfterPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    private readonly condition;
+    private readonly maxAttempts;
+    private readonly timeout;
+    order: number;
+    constructor(options?: RetryAfterPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): void;
+    private parseRetryAfterHeader;
+    private delayExecution;
+}
+
 interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
     /**
      * The name of the header to check.
      *
      * @default 'x-csrf-token'
      */
-    headerName?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    headerName?: Value<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
     /**
      * The value of the header to check.
      *
      * @default 'orpc'
      *
      */
-    headerValue?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    headerValue?: Value<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
     /**
      * Exclude a procedure from the plugin.
      *
      * @default false
      */
-    exclude?: Value<boolean, [options: StandardLinkClientInterceptorOptions<T>]>;
+    exclude?: Value<Promisable<boolean>, [options: StandardLinkClientInterceptorOptions<T>]>;
 }
 /**
  * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
@@ -158,5 +245,5 @@ declare class SimpleCsrfProtectionLinkPlugin<T extends ClientContext> implements
     init(options: StandardLinkOptions<T>): void;
 }
 
-export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };
-export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, SimpleCsrfProtectionLinkPluginOptions };
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, DedupeRequestsPluginGroup, DedupeRequestsPluginOptions, RetryAfterPluginOptions, SimpleCsrfProtectionLinkPluginOptions };

package/dist/plugins/index.mjs

@@ -1,6 +1,7 @@
-import { isAsyncIteratorObject, value, splitInHalf, toArray } from '@orpc/shared';
-import { toBatchRequest, parseBatchResponse } from '@orpc/standard-server/batch';
-import { getEventMeta } from '@orpc/standard-server';
+import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON, overlayProxy, AsyncIteratorClass } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse, toBatchAbortSignal } from '@orpc/standard-server/batch';
+import { replicateStandardLazyResponse, getEventMeta, flattenHeader } from '@orpc/standard-server';
+import { C as COMMON_ORPC_ERROR_DEFS } from '../shared/client.DaTrs7SW.mjs';
 
 class BatchLinkPlugin {
   groups;
@@ -10,6 +11,7 @@ class BatchLinkPlugin {
   batchHeaders;
   mapRequestItem;
   exclude;
+  mode;
   pending;
   order = 5e6;
   constructor(options) {
@@ -17,6 +19,7 @@ class BatchLinkPlugin {
     this.pending = /* @__PURE__ */ new Map();
     this.maxSize = options.maxSize ?? 10;
     this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.mode = options.mode ?? "streaming";
     this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
     this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
       const headers = {};
@@ -62,7 +65,7 @@ class BatchLinkPlugin {
       });
     });
     options.clientInterceptors.push((options2) => {
-      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body) || options2.request.signal?.aborted) {
         return options2.next();
       }
       const group = this.groups.find((group2) => group2.condition(options2));
@@ -71,7 +74,7 @@ class BatchLinkPlugin {
       }
       return new Promise((resolve, reject) => {
         this.#enqueueRequest(group, options2, resolve, reject);
-        setTimeout(() => this.#processPendingBatches());
+        defer(() => this.#processPendingBatches());
       });
     });
   }
@@ -127,16 +130,28 @@ class BatchLinkPlugin {
         this.#executeBatch(method, group, second);
         return;
       }
-      const lazyResponse = await options[0].next({
-        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": "1" } },
-        signal: batchRequest.signal,
-        context: group.context,
-        input: group.input,
-        path: toArray(group.path)
-      });
-      const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
-      for await (const item of parsed) {
-        batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+      const mode = value(this.mode, options);
+      try {
+        const lazyResponse = await options[0].next({
+          request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
+          signal: batchRequest.signal,
+          context: group.context,
+          input: group.input,
+          path: toArray(group.path)
+        });
+        const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
+        for await (const item of parsed) {
+          batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+        }
+      } catch (err) {
+        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
+          for (const [{ signal }, , reject] of batchItems) {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            }
+          }
+        }
+        throw err;
       }
       throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
     } catch (error) {
@@ -147,6 +162,101 @@ class BatchLinkPlugin {
   }
 }
 
+class DedupeRequestsPlugin {
+  #groups;
+  #filter;
+  order = 4e6;
+  // make sure execute before batch plugin
+  #queue = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#groups = options.groups;
+    this.#filter = options.filter ?? (({ request }) => request.method === "GET");
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push((options2) => {
+      if (options2.request.body instanceof Blob || options2.request.body instanceof FormData || options2.request.body instanceof URLSearchParams || isAsyncIteratorObject(options2.request.body) || !this.#filter(options2)) {
+        return options2.next();
+      }
+      const group = this.#groups.find((group2) => group2.condition(options2));
+      if (!group) {
+        return options2.next();
+      }
+      return new Promise((resolve, reject) => {
+        this.#enqueue(group, options2, resolve, reject);
+        defer(() => this.#dequeue());
+      });
+    });
+  }
+  #enqueue(group, options, resolve, reject) {
+    let queue = this.#queue.get(group);
+    if (!queue) {
+      this.#queue.set(group, queue = []);
+    }
+    const matched = queue.find((item) => {
+      const requestString1 = stringifyJSON({
+        body: item.options.request.body,
+        headers: item.options.request.headers,
+        method: item.options.request.method,
+        url: item.options.request.url
+      });
+      const requestString2 = stringifyJSON({
+        body: options.request.body,
+        headers: options.request.headers,
+        method: options.request.method,
+        url: options.request.url
+      });
+      return requestString1 === requestString2;
+    });
+    if (matched) {
+      matched.signals.push(options.request.signal);
+      matched.resolves.push(resolve);
+      matched.rejects.push(reject);
+    } else {
+      queue.push({
+        options,
+        signals: [options.request.signal],
+        resolves: [resolve],
+        rejects: [reject]
+      });
+    }
+  }
+  async #dequeue() {
+    const promises = [];
+    for (const [group, items] of this.#queue) {
+      for (const { options, signals, resolves, rejects } of items) {
+        promises.push(
+          this.#execute(group, options, signals, resolves, rejects)
+        );
+      }
+    }
+    this.#queue.clear();
+    await Promise.all(promises);
+  }
+  async #execute(group, options, signals, resolves, rejects) {
+    try {
+      const dedupedRequest = {
+        ...options.request,
+        signal: toBatchAbortSignal(signals)
+      };
+      const response = await options.next({
+        ...options,
+        request: dedupedRequest,
+        signal: dedupedRequest.signal,
+        context: group.context
+      });
+      const replicatedResponses = replicateStandardLazyResponse(response, resolves.length);
+      for (const resolve of resolves) {
+        resolve(replicatedResponses.shift());
+      }
+    } catch (error) {
+      for (const reject of rejects) {
+        reject(error);
+      }
+    }
+  }
+}
+
 class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
 }
 class ClientRetryPlugin {
@@ -154,6 +264,7 @@ class ClientRetryPlugin {
   defaultRetryDelay;
   defaultShouldRetry;
   defaultOnRetry;
+  order = 18e5;
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
     this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
@@ -208,7 +319,7 @@ class ClientRetryPlugin {
             return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
             currentError = { error };
-            if (updatedInterceptorOptions.signal?.aborted === true) {
+            if (updatedInterceptorOptions.signal?.aborted) {
               throw error;
             }
           } finally {
@@ -221,19 +332,17 @@ class ClientRetryPlugin {
       if (!isAsyncIteratorObject(output)) {
         return output;
       }
-      return async function* () {
-        let current = output;
-        try {
+      let current = output;
+      let isIteratorAborted = false;
+      return overlayProxy(() => current, new AsyncIteratorClass(
+        async () => {
           while (true) {
             try {
               const item = await current.next();
               const meta = getEventMeta(item.value);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              if (item.done) {
-                return item.value;
-              }
-              yield item.value;
+              return item;
             } catch (error) {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
@@ -245,12 +354,97 @@ class ClientRetryPlugin {
                 );
               }
               current = maybeEventIterator;
+              if (isIteratorAborted) {
+                await current.return?.();
+                throw error;
+              }
             }
           }
-        } finally {
-          await current.return?.();
+        },
+        async (reason) => {
+          isIteratorAborted = true;
+          if (reason !== "next") {
+            await current.return?.();
+          }
         }
-      }();
+      ));
+    });
+  }
+}
+
+class RetryAfterPlugin {
+  condition;
+  maxAttempts;
+  timeout;
+  order = 19e5;
+  constructor(options = {}) {
+    this.condition = options.condition ?? ((response) => response.status === COMMON_ORPC_ERROR_DEFS.TOO_MANY_REQUESTS.status || response.status === COMMON_ORPC_ERROR_DEFS.SERVICE_UNAVAILABLE.status);
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.timeout = options.timeout ?? 5 * 60 * 1e3;
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (interceptorOptions) => {
+      const startTime = Date.now();
+      let attemptCount = 0;
+      while (true) {
+        attemptCount++;
+        const response = await interceptorOptions.next();
+        if (!value(this.condition, response, interceptorOptions)) {
+          return response;
+        }
+        const retryAfterHeader = flattenHeader(response.headers["retry-after"]);
+        const retryAfterMs = this.parseRetryAfterHeader(retryAfterHeader);
+        if (retryAfterMs === void 0) {
+          return response;
+        }
+        if (attemptCount >= value(this.maxAttempts, response, interceptorOptions)) {
+          return response;
+        }
+        const timeoutMs = value(this.timeout, response, interceptorOptions);
+        const elapsedTime = Date.now() - startTime;
+        if (elapsedTime + retryAfterMs > timeoutMs) {
+          return response;
+        }
+        await this.delayExecution(retryAfterMs, interceptorOptions.signal);
+        if (interceptorOptions.signal?.aborted) {
+          return response;
+        }
+      }
+    });
+  }
+  parseRetryAfterHeader(value2) {
+    value2 = value2?.trim();
+    if (!value2) {
+      return void 0;
+    }
+    const seconds = Number(value2);
+    if (Number.isFinite(seconds)) {
+      return Math.max(0, seconds * 1e3);
+    }
+    const retryDate = Date.parse(value2);
+    if (!Number.isNaN(retryDate)) {
+      return Math.max(0, retryDate - Date.now());
+    }
+    return void 0;
+  }
+  delayExecution(ms, signal) {
+    return new Promise((resolve) => {
+      if (signal?.aborted) {
+        resolve();
+        return;
+      }
+      let timeout;
+      const onAbort = () => {
+        clearTimeout(timeout);
+        timeout = void 0;
+        resolve();
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      timeout = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      }, ms);
     });
   }
 }
@@ -288,4 +482,4 @@ class SimpleCsrfProtectionLinkPlugin {
   }
 }
 
-export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };

package/dist/shared/client.BH1AYT_p.d.mts

@@ -0,0 +1,83 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrors<T[K]> : never;
+};
+/**
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientErrorUnion<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrorUnion<T[K]> : never;
+}[keyof T];
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f, InferClientInputs as g, InferClientBodyInputs as h, InferClientOutputs as i, InferClientBodyOutputs as j, InferClientErrors as k, InferClientErrorUnion as l };