@orpc/client 1.14.6 → 2.0.0-beta.10

package/dist/index.mjs

@@ -1,38 +1,71 @@
-import { preventNativeAwait, isTypescriptObject } from '@orpc/shared';
-export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-import { i as isDefinedError } from './shared/client.D9eWXdBV.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, t as toORPCError } from './shared/client.D9eWXdBV.mjs';
-export { m as mapEventIterator } from './shared/client.BLtwTQUg.mjs';
-export { ErrorEvent, getEventMeta, withEventMeta } from '@orpc/standard-server';
+import { a as isInferableError } from './shared/client.D3TIIok6.mjs';
+export { b as RPCJsonSerializer, R as RPCSerializer, d as cloneORPCError, c as createORPCErrorFromJson, i as isORPCErrorJson, t as toORPCError, w as wrapEventIteratorPreservingMeta } from './shared/client.D3TIIok6.mjs';
+import { getOrBind, toArray, intercept, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+export { C as COMMON_ERROR_STATUS_MAP, O as ORPCError } from './shared/client.Dnfj8jnT.mjs';
+export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
 
+const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
+  /**
+   * Prevents the client from being treated as a thenable when users
+   * accidentally write `await client`.
+   */
+  "then",
+  /**
+   * Commonly used by libraries to bind functions to a specific `this`
+   * context.
+   */
+  "bind",
+  /**
+   * Commonly accessed during primitive conversion, inspection, and logging.
+   */
+  "valueOf",
+  /**
+   * Commonly accessed during string conversion, inspection, and logging.
+   */
+  "toString",
+  /**
+   * Commonly accessed by serializers such as `JSON.stringify`.
+   */
+  "toJSON"
+]);
+
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+function resolveClientRest(rest) {
+  return [
+    rest[0],
+    // rest[0] can be undefined if TInput is optional,
+    resolveFriendlyClientOptions(rest[1] ?? {})
+    // rest[1] can be undefined if all fields of FriendlyClientOptions are optional
+  ];
+}
 async function safe(promise) {
   try {
     const output = await promise;
     return Object.assign(
-      [null, output, false, true],
-      { error: null, data: output, isDefined: false, isSuccess: true }
+      [null, output, null, true],
+      { error: null, data: output, inferableError: null, isSuccess: true }
     );
   } catch (e) {
     const error = e;
-    if (isDefinedError(error)) {
+    if (isInferableError(error)) {
       return Object.assign(
-        [error, void 0, true, false],
-        { error, data: void 0, isDefined: true, isSuccess: false }
+        [error, void 0, error, false],
+        { error, data: void 0, inferableError: error, isSuccess: false }
       );
     }
     return Object.assign(
-      [error, void 0, false, false],
-      { error, data: void 0, isDefined: false, isSuccess: false }
+      [error, void 0, null, false],
+      { error, data: void 0, inferableError: null, isSuccess: false }
     );
   }
 }
-function resolveFriendlyClientOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
 function consumeEventIterator(iterator, options) {
   void (async () => {
     let onFinishState;
@@ -63,32 +96,39 @@ function consumeEventIterator(iterator, options) {
   };
 }
 
-function createORPCClient(link, options = {}) {
-  const path = options.path ?? [];
-  const procedureClient = async (...[input, options2 = {}]) => {
-    return await link.call(path, input, resolveFriendlyClientOptions(options2));
+function createORPCClient(link, { path = [], ...options } = {}) {
+  const procedureClient = (...rest) => {
+    const [input, callOptions] = resolveClientRest(rest);
+    const interceptors = [
+      ...toArray(options.interceptors),
+      ...toArray(options.scoped?.interceptors)
+    ];
+    return intercept(
+      interceptors,
+      { ...callOptions, input, path },
+      ({ path: path2, input: input2, ...callOptions2 }) => link.call(path2, input2, callOptions2)
+    );
   };
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
-      if (typeof key !== "string") {
-        return Reflect.get(target, key);
+      if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
+        return getOrBind(target, key);
       }
+      const scoped = options.scoped === void 0 ? void 0 : options.scoped[key];
       return createORPCClient(link, {
         ...options,
-        path: [...path, key]
+        path: [...path, key],
+        scoped
       });
     }
   });
-  return preventNativeAwait(recursive);
+  return 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;
-      }
+    get(_, prop) {
+      const value = getOrBind(client, prop);
       if (!isTypescriptObject(value)) {
         return value;
       }
@@ -109,4 +149,6 @@ class DynamicLink {
   }
 }
 
-export { DynamicLink, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };
+const isDefinedError = isInferableError;
+
+export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, isInferableError, resolveClientRest, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -1,168 +1,200 @@
 import { Value, Promisable } from '@orpc/shared';
-import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { BatchResponseMode } from '@orpc/standard-server/batch';
-import { b as ClientContext } from '../shared/client.i2uoJbEp.mjs';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.CpCa3si8.mjs';
+import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { C as ClientContext } from '../shared/client.8ug8I-zu.mjs';
+import { c as StandardLinkPlugin, d as StandardLinkTransportInterceptorOptions, b as StandardLinkOptions, e as StandardLinkInterceptorOptions } from '../shared/client.Cby_-GGh.mjs';
 
+type BatchLinkPluginMode = 'streaming' | 'buffered';
 interface BatchLinkPluginGroup<T extends ClientContext> {
-    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
-    context: T;
-    path?: readonly string[];
-    input?: unknown;
+    /**
+     * Determines whether a request should be included in this batch group.
+     * Requests will be evaluated against each group's condition in order,
+     * and included in the first group whose condition returns true.
+     * If no group's condition returns true, the request will not be batched.
+     */
+    condition: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
+    /**
+     * The client context applied to requests in this batch group for the remainder of the link chain.
+     */
+    context: Value<T, [items: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+    /**
+     * The path segments applied to requests in this batch group for the remainder of the link chain.
+     *
+     * @default []
+     */
+    path?: Value<string[], [items: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
+}
+declare class BatchLinkPluginError extends TypeError {
 }
 interface BatchLinkPluginOptions<T extends ClientContext> {
-    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    groups: [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    /**
+     * Filters requests to batch.
+     *
+     * @default () => true
+     */
+    filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
     /**
      * The maximum number of requests in the batch.
      *
      * @default 10
      */
-    maxSize?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    maxSize?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
     /**
      * The batch response mode.
      *
      * @default 'streaming'
      */
-    mode?: Value<BatchResponseMode, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    mode?: Value<BatchLinkPluginMode, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
     /**
-     * Defines the URL to use for the batch request.
+     * URL for the batch request.
      *
-     * @default the URL of the first request in the batch + '/__batch__'
+     * @default URL of the first subrequest in the batch + '/__batch__'
      */
-    url?: Value<Promisable<string | URL>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    url?: Value<Promisable<StandardUrl>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
     /**
-     * The maximum length of the URL.
+     * The maximum length of the URL that runtime supports,
+     * if exceeded, the batch will be split into smaller batches and sent sequentially.
+     *
+     * This only applies to GET batch requests where the batch data is sent via URL query parameter.
      *
      * @default 2083
      */
-    maxUrlLength?: Value<Promisable<number>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    maxUrlLength?: Value<Promisable<number>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
     /**
-     * Defines the HTTP headers to use for the batch request.
+     * Headers used for the batch request.
      *
-     * @default The same headers of all requests in the batch
+     * @default Common headers among all subrequests in the batch.
      */
-    headers?: Value<Promisable<StandardHeaders>, [readonly [StandardLinkClientInterceptorOptions<T>, ...StandardLinkClientInterceptorOptions<T>[]]]>;
+    headers?: Value<Promisable<StandardHeaders>, [subOptionsList: [StandardLinkTransportInterceptorOptions<T>, ...StandardLinkTransportInterceptorOptions<T>[]]]>;
     /**
-     * Map the batch request items before sending them.
+     * Map each subrequest in the batch before it is sent.
      *
-     * @default Removes headers that are duplicated in the batch headers.
+     * @default Removes headers that are duplicated with the batch headers
      */
-    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
-        batchUrl: URL;
-        batchHeaders: StandardHeaders;
-    }) => StandardRequest;
+    mapSubrequest?: (subOptions: StandardLinkTransportInterceptorOptions<T>, partialBatchRequest: Pick<StandardRequest, 'url' | 'headers'>) => StandardRequest;
     /**
-     * Exclude a request from the batch.
+     * Maps each subresponse before returning the final response.
      *
-     * @default () => false
+     * @default Low-priority merges headers from the batch response into each subresponse.
      */
-    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+    mapSubresponse?: (subResponse: StandardLazyResponse, batchResponse: StandardLazyResponse, subOptions: StandardLinkTransportInterceptorOptions<T>) => StandardLazyResponse;
 }
-/**
- * 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.dev/docs/plugins/batch-requests Batch Requests Plugin Docs}
- */
 declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    #private;
+    name: string;
     private readonly groups;
+    private readonly filter;
     private readonly maxSize;
+    private readonly mode;
     private readonly batchUrl;
     private readonly maxUrlLength;
     private readonly batchHeaders;
-    private readonly mapRequestItem;
-    private readonly exclude;
-    private readonly mode;
-    private pending;
-    order: number;
+    private readonly mapSubrequest;
+    private readonly mapSubresponse;
+    private readonly queue;
     constructor(options: NoInfer<BatchLinkPluginOptions<T>>);
-    init(options: StandardLinkOptions<T>): void;
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+    private processPendingBatches;
+    private executeBatch;
 }
 
-interface DedupeRequestsPluginGroup<T extends ClientContext> {
-    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+interface DedupeLinkPluginGroup<T extends ClientContext> {
+    condition: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
     /**
      * The context used for the rest of the request lifecycle.
      */
-    context: T;
+    context: Value<T, [
+        items: [
+            StandardLinkTransportInterceptorOptions<T>,
+            StandardLinkTransportInterceptorOptions<T>,
+            ...StandardLinkTransportInterceptorOptions<T>[]
+        ]
+    ]>;
 }
-interface DedupeRequestsPluginOptions<T extends ClientContext> {
+interface DedupeLinkPluginOptions<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>[]];
+    groups: [DedupeLinkPluginGroup<T>, ...DedupeLinkPluginGroup<T>[]];
     /**
-     * Filters requests to dedupe
+     * Filters requests to dedupe.
      *
-     * @default (({ request }) => request.method === 'GET')
+     * @default ({ request }) => request.method === 'GET'
      */
-    filter?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+    filter?: Value<boolean, [options: StandardLinkTransportInterceptorOptions<T>]>;
 }
-/**
- * Prevents duplicate requests by deduplicating similar ones to reduce server load.
- *
- * @see {@link https://orpc.dev/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;
+declare class DedupeLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    name: string;
+    before: string[];
+    private readonly groups;
+    private readonly filter;
+    private readonly queue;
+    constructor(options: NoInfer<DedupeLinkPluginOptions<T>>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
+    private enqueue;
+    private processPendingRequests;
+    private execute;
 }
 
-interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+interface RetryLinkPluginAttemptOptions<T extends RetryLinkPluginContext> extends StandardLinkInterceptorOptions<T> {
+    /**
+     * Latest retry delay advertised by the server via event metadata.
+     */
     lastEventRetry: number | undefined;
-    attemptIndex: number;
+    /**
+     * Current retry attempt number, starting at 1.
+     */
+    attempt: number;
+    /**
+     * Error that triggered this retry attempt.
+     */
     error: unknown;
 }
-interface ClientRetryPluginContext {
+interface RetryLinkPluginContext {
     /**
-     * Maximum retry attempts before throwing
-     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     * Maximum retry attempts before throwing.
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g. for event iterators).
      *
      * @default 0
      */
-    retry?: Value<Promisable<number>, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    retry?: Value<Promisable<number>, [Omit<StandardLinkInterceptorOptions<RetryLinkPluginContext>, 'next'>]>;
     /**
      * Delay (in ms) before retrying.
      *
+     * @info Why 2000ms? The EventSource spec suggests a default retry delay of 2 seconds if it doesn't specify
      * @default (o) => o.lastEventRetry ?? 2000
      */
-    retryDelay?: Value<Promisable<number>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    retryDelay?: Value<Promisable<number>, [RetryLinkPluginAttemptOptions<RetryLinkPluginContext>]>;
     /**
-     * Determine should retry or not.
+     * Determine whether to retry.
      *
      * @default true
      */
-    shouldRetry?: Value<Promisable<boolean>, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    shouldRetry?: Value<Promisable<boolean>, [RetryLinkPluginAttemptOptions<RetryLinkPluginContext>]>;
     /**
-     * The hook called when retrying, and return the unsubscribe function.
+     * Hook called before each retry. Can return a cleanup callback.
      */
-    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | ((isSuccess: boolean) => void);
+    onRetry?: (options: RetryLinkPluginAttemptOptions<RetryLinkPluginContext>) => void | ((isSuccess: boolean) => void);
 }
-declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+interface RetryLinkPluginOptions<_T extends RetryLinkPluginContext> {
+    /**
+     * Default retry options. Can be overridden by individual calls via the context.
+     */
+    default?: RetryLinkPluginContext | undefined;
 }
-interface ClientRetryPluginOptions {
-    default?: ClientRetryPluginContext;
+declare class RetryLinkPluginInvalidEventIteratorRetryResponse extends Error {
 }
-/**
- * The Client Retry Plugin enables retrying client calls when errors occur.
- *
- * @see {@link https://orpc.dev/docs/plugins/client-retry Client Retry Plugin Docs}
- */
-declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+declare class RetryLinkPlugin<T extends RetryLinkPluginContext & ClientContext> implements StandardLinkPlugin<T> {
     private readonly defaultRetry;
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
     private readonly defaultOnRetry;
-    order: number;
-    constructor(options?: ClientRetryPluginOptions);
-    init(options: StandardLinkOptions<T>): void;
+    name: string;
+    constructor(options?: RetryLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
 }
 
-interface RetryAfterPluginOptions<T extends ClientContext> {
+interface RetryAfterLinkPluginOptions<T extends ClientContext> {
     /**
      * Override condition to determine whether to retry or not.
      *
@@ -170,7 +202,7 @@ interface RetryAfterPluginOptions<T extends ClientContext> {
      */
     condition?: Value<boolean, [
         response: StandardLazyResponse,
-        options: StandardLinkClientInterceptorOptions<T>
+        options: StandardLinkTransportInterceptorOptions<T>
     ]>;
     /**
      * Maximum attempts before giving up retries.
@@ -179,7 +211,7 @@ interface RetryAfterPluginOptions<T extends ClientContext> {
      */
     maxAttempts?: Value<number, [
         response: StandardLazyResponse,
-        options: StandardLinkClientInterceptorOptions<T>
+        options: StandardLinkTransportInterceptorOptions<T>
     ]>;
     /**
      * Maximum timeout in milliseconds to wait before giving up retries.
@@ -188,62 +220,23 @@ interface RetryAfterPluginOptions<T extends ClientContext> {
      */
     timeout?: Value<number, [
         response: StandardLazyResponse,
-        options: StandardLinkClientInterceptorOptions<T>
+        options: StandardLinkTransportInterceptorOptions<T>
     ]>;
 }
 /**
- * The Retry After Plugin automatically retries requests based on server `Retry-After` headers.
+ * The Retry After Link Plugin automatically retries requests based on server `retry-after` header.
  * This is particularly useful for handling rate limiting and temporary server unavailability.
  *
  * @see {@link https://orpc.dev/docs/plugins/retry-after Retry After Plugin Docs}
  */
-declare class RetryAfterPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+declare class RetryAfterLinkPlugin<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<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
-    /**
-     * The value of the header to check.
-     *
-     * @default 'orpc'
-     *
-     */
-    headerValue?: Value<Promisable<string>, [options: StandardLinkClientInterceptorOptions<T>]>;
-    /**
-     * Exclude a procedure from the plugin.
-     *
-     * @default false
-     */
-    exclude?: Value<Promisable<boolean>, [options: StandardLinkClientInterceptorOptions<T>]>;
-}
-/**
- * This plugin adds basic Cross-Site Request Forgery (CSRF) protection to your oRPC application.
- * It helps ensure that requests to your procedures originate from JavaScript code,
- * not from other sources like standard HTML forms or direct browser navigation.
- *
- * @see {@link https://orpc.dev/docs/plugins/simple-csrf-protection Simple CSRF Protection Plugin Docs}
- */
-declare class SimpleCsrfProtectionLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
-    private readonly headerName;
-    private readonly headerValue;
-    private readonly exclude;
-    constructor(options?: SimpleCsrfProtectionLinkPluginOptions<T>);
-    order: number;
-    init(options: StandardLinkOptions<T>): void;
+    name: string;
+    constructor(options?: RetryAfterLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): StandardLinkOptions<T>;
 }
 
-export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };
-export type { BatchLinkPluginGroup, BatchLinkPluginOptions, ClientRetryPluginAttemptOptions, ClientRetryPluginContext, ClientRetryPluginOptions, DedupeRequestsPluginGroup, DedupeRequestsPluginOptions, RetryAfterPluginOptions, SimpleCsrfProtectionLinkPluginOptions };
+export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, RetryLinkPluginInvalidEventIteratorRetryResponse };
+export type { BatchLinkPluginGroup, BatchLinkPluginMode, BatchLinkPluginOptions, DedupeLinkPluginGroup, DedupeLinkPluginOptions, RetryAfterLinkPluginOptions, RetryLinkPluginAttemptOptions, RetryLinkPluginContext, RetryLinkPluginOptions };