@orpc/client 0.0.0-next.f72e6b9 → 0.0.0-next.f7af1c4

package/dist/index.d.mts

@@ -1,14 +1,14 @@
-import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.CipPQkhk.mjs';
-export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.CipPQkhk.mjs';
-import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
-export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.mjs';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.mjs';
+import { MaybeOptionalOptions, ThrowableError, OnFinishState, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    path?: string[];
+    path?: readonly string[];
 }
 /**
  * Create a oRPC client-side client from a link.
@@ -17,18 +17,6 @@ interface createORPCClientOptions {
  */
 declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 
-/**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
- */
-declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-}
-
 declare const COMMON_ORPC_ERROR_DEFS: {
     readonly BAD_REQUEST: {
         readonly status: 400;
@@ -125,8 +113,21 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
+    /**
+     * Workaround for Next.js where different contexts use separate
+     * dependency graphs, causing multiple ORPCError constructors existing and breaking
+     * `instanceof` checks across contexts.
+     *
+     * This is particularly problematic with "Optimized SSR", where orpc-client
+     * executes in one context but is invoked from another. When an error is thrown
+     * in the execution context, `instanceof ORPCError` checks fail in the
+     * invocation context due to separate class constructors.
+     *
+     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
@@ -135,11 +136,6 @@ declare function isORPCErrorStatus(status: number): boolean;
 declare function isORPCErrorJson(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 declare function createORPCErrorFromJson<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
 
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-
 type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
@@ -164,6 +160,71 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false
  */
 declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+interface ConsumeEventIteratorOptions<T, TReturn, TError> {
+    /**
+     * Called on each event
+     */
+    onEvent: (event: T) => void;
+    /**
+     * Called once error happens
+     */
+    onError?: (error: TError) => void;
+    /**
+     * Called once event iterator is done
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onSuccess?: (value: TReturn | undefined) => void;
+    /**
+     * Called once after onError or onSuccess
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onFinish?: (state: OnFinishState<TReturn | undefined, TError>) => void;
+}
+/**
+ * Consumes an event iterator with lifecycle callbacks
+ *
+ * @warning If no `onError` or `onFinish` is provided, unhandled rejections will be thrown
+ * @return unsubscribe callback
+ */
+declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | ClientPromiseResult<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
+
+type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
+};
+/**
+ * Create a safe client that automatically wraps all procedure calls with the `safe` util.
+ *
+ * @example
+ * ```ts
+ * const safeClient = createSafeClient(client)
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * ```
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ */
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+
+declare const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+declare const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.f7af1c4";
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncIteratorClass<TMap, TMap, TNext>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
-export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeResult, createORPCClientOptions };
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, ORPC_CLIENT_PACKAGE_NAME, ORPC_CLIENT_PACKAGE_VERSION, consumeEventIterator, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ConsumeEventIteratorOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };

package/dist/index.d.ts

@@ -1,14 +1,14 @@
-import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.CipPQkhk.js';
-export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.CipPQkhk.js';
-import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
-export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.js';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.js';
+import { MaybeOptionalOptions, ThrowableError, OnFinishState, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    path?: string[];
+    path?: readonly string[];
 }
 /**
  * Create a oRPC client-side client from a link.
@@ -17,18 +17,6 @@ interface createORPCClientOptions {
  */
 declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 
-/**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
- */
-declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-}
-
 declare const COMMON_ORPC_ERROR_DEFS: {
     readonly BAD_REQUEST: {
         readonly status: 400;
@@ -125,8 +113,21 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
+    /**
+     * Workaround for Next.js where different contexts use separate
+     * dependency graphs, causing multiple ORPCError constructors existing and breaking
+     * `instanceof` checks across contexts.
+     *
+     * This is particularly problematic with "Optimized SSR", where orpc-client
+     * executes in one context but is invoked from another. When an error is thrown
+     * in the execution context, `instanceof ORPCError` checks fail in the
+     * invocation context due to separate class constructors.
+     *
+     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
@@ -135,11 +136,6 @@ declare function isORPCErrorStatus(status: number): boolean;
 declare function isORPCErrorJson(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 declare function createORPCErrorFromJson<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
 
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-
 type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
@@ -164,6 +160,71 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false
  */
 declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+interface ConsumeEventIteratorOptions<T, TReturn, TError> {
+    /**
+     * Called on each event
+     */
+    onEvent: (event: T) => void;
+    /**
+     * Called once error happens
+     */
+    onError?: (error: TError) => void;
+    /**
+     * Called once event iterator is done
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onSuccess?: (value: TReturn | undefined) => void;
+    /**
+     * Called once after onError or onSuccess
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onFinish?: (state: OnFinishState<TReturn | undefined, TError>) => void;
+}
+/**
+ * Consumes an event iterator with lifecycle callbacks
+ *
+ * @warning If no `onError` or `onFinish` is provided, unhandled rejections will be thrown
+ * @return unsubscribe callback
+ */
+declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | ClientPromiseResult<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
+
+type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
+};
+/**
+ * Create a safe client that automatically wraps all procedure calls with the `safe` util.
+ *
+ * @example
+ * ```ts
+ * const safeClient = createSafeClient(client)
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * ```
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ */
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+
+declare const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+declare const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.f7af1c4";
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncIteratorClass<TMap, TMap, TNext>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
-export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeResult, createORPCClientOptions };
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, ORPC_CLIENT_PACKAGE_NAME, ORPC_CLIENT_PACKAGE_VERSION, consumeEventIterator, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ConsumeEventIteratorOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { i as isDefinedError } from './shared/client.CRWEpqLB.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, d as createORPCErrorFromJson, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, c as isORPCErrorJson, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.CRWEpqLB.mjs';
-export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { preventNativeAwait, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+import { i as isDefinedError } from './shared/client.9Pe_7OOW.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, c as ORPCError, O as ORPC_CLIENT_PACKAGE_NAME, a as ORPC_CLIENT_PACKAGE_VERSION, g as createORPCErrorFromJson, b as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, e as isORPCErrorJson, d as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.9Pe_7OOW.mjs';
 export { ErrorEvent } from '@orpc/standard-server';
 
 async function safe(promise) {
@@ -27,13 +28,42 @@ async function safe(promise) {
 function resolveFriendlyClientOptions(options) {
   return {
     ...options,
-    context: options?.context ?? {}
+    context: options.context ?? {}
     // Context only optional if all fields are optional
   };
 }
+function consumeEventIterator(iterator, options) {
+  void (async () => {
+    let onFinishState;
+    try {
+      const resolvedIterator = await iterator;
+      while (true) {
+        const { done, value } = await resolvedIterator.next();
+        if (done) {
+          const realValue = value;
+          onFinishState = [null, realValue, true];
+          options.onSuccess?.(realValue);
+          break;
+        }
+        options.onEvent(value);
+      }
+    } catch (error) {
+      onFinishState = [error, void 0, false];
+      if (!options.onError && !options.onFinish) {
+        throw error;
+      }
+      options.onError?.(error);
+    } finally {
+      options.onFinish?.(onFinishState);
+    }
+  })();
+  return async () => {
+    await (await iterator)?.return?.();
+  };
+}
 
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
   const procedureClient = async (...[input, options2 = {}]) => {
     return await link.call(path, input, resolveFriendlyClientOptions(options2));
   };
@@ -48,7 +78,23 @@ function createORPCClient(link, options) {
       });
     }
   });
-  return recursive;
+  return preventNativeAwait(recursive);
+}
+
+function createSafeClient(client) {
+  const proxy = new Proxy((...args) => safe(client(...args)), {
+    get(_, prop, receiver) {
+      const value = Reflect.get(client, prop, receiver);
+      if (typeof prop !== "string") {
+        return value;
+      }
+      if (!isTypescriptObject(value)) {
+        return value;
+      }
+      return createSafeClient(value);
+    }
+  });
+  return proxy;
 }
 
 class DynamicLink {
@@ -62,4 +108,4 @@ class DynamicLink {
   }
 }
 
-export { DynamicLink, createORPCClient, isDefinedError, resolveFriendlyClientOptions, safe };
+export { DynamicLink, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -1,7 +1,8 @@
-import { Value } from '@orpc/shared';
+import { Value, Promisable } 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.FXep-a3a.mjs';
-import { a as ClientContext } from '../shared/client.CipPQkhk.mjs';
+import { BatchResponseMode } from '@orpc/standard-server/batch';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.Bwgm6dgk.mjs';
+import { b as ClientContext } from '../shared/client.BOYsZIRq.mjs';
 
 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,6 +157,7 @@ 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;
 }
@@ -127,20 +168,20 @@ interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
      *
      * @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 +199,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, SimpleCsrfProtectionLinkPlugin };
+export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, DedupeRequestsPluginGroup, DedupeRequestsPluginOptions, SimpleCsrfProtectionLinkPluginOptions };