@orpc/client 0.0.0-next.c59d67c → 0.0.0-next.c72b962

package/dist/plugins/index.d.mts

@@ -0,0 +1,143 @@
+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.2CWETx1V.mjs';
+import { a as ClientContext } from '../shared/client.CipPQkhk.mjs';
+
+interface BatchLinkPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    context: T;
+    path?: readonly string[];
+    input?: unknown;
+}
+interface BatchLinkPluginOptions<T extends ClientContext> {
+    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    /**
+     * The maximum number of requests in the batch.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [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>[]]]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<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>[]]]>;
+    /**
+     * Map the batch request items before sending them.
+     *
+     * @default Removes headers that are duplicated in the batch headers.
+     */
+    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
+        batchUrl: URL;
+        batchHeaders: StandardHeaders;
+    }) => StandardRequest;
+    /**
+     * Exclude a request from the batch.
+     *
+     * @default () => false
+     */
+    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+}
+declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    private readonly groups;
+    private readonly maxSize;
+    private readonly batchUrl;
+    private readonly maxUrlLength;
+    private readonly batchHeaders;
+    private readonly mapRequestItem;
+    private readonly exclude;
+    private pending;
+    order: number;
+    constructor(options: BatchLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    lastEventRetry: number | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
+    /**
+     * The name of the header to check.
+     *
+     * @default 'x-csrf-token'
+     */
+    headerName?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * The value of the header to check.
+     *
+     * @default 'orpc'
+     *
+     */
+    headerValue?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * Exclude a procedure from the plugin.
+     *
+     * @default false
+     */
+    exclude?: Value<boolean, [options: StandardLinkClientInterceptorOptions<T>]>;
+}
+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;
+}
+
+export { BatchLinkPlugin, type BatchLinkPluginGroup, type BatchLinkPluginOptions, ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions, SimpleCsrfProtectionLinkPlugin, type SimpleCsrfProtectionLinkPluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,143 @@
+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.DUjXqpDq.js';
+import { a as ClientContext } from '../shared/client.CipPQkhk.js';
+
+interface BatchLinkPluginGroup<T extends ClientContext> {
+    condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
+    context: T;
+    path?: readonly string[];
+    input?: unknown;
+}
+interface BatchLinkPluginOptions<T extends ClientContext> {
+    groups: readonly [BatchLinkPluginGroup<T>, ...BatchLinkPluginGroup<T>[]];
+    /**
+     * The maximum number of requests in the batch.
+     *
+     * @default 10
+     */
+    maxSize?: Value<number, [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>[]]]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<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>[]]]>;
+    /**
+     * Map the batch request items before sending them.
+     *
+     * @default Removes headers that are duplicated in the batch headers.
+     */
+    mapRequestItem?: (options: StandardLinkClientInterceptorOptions<T> & {
+        batchUrl: URL;
+        batchHeaders: StandardHeaders;
+    }) => StandardRequest;
+    /**
+     * Exclude a request from the batch.
+     *
+     * @default () => false
+     */
+    exclude?: (options: StandardLinkClientInterceptorOptions<T>) => boolean;
+}
+declare class BatchLinkPlugin<T extends ClientContext> implements StandardLinkPlugin<T> {
+    #private;
+    private readonly groups;
+    private readonly maxSize;
+    private readonly batchUrl;
+    private readonly maxUrlLength;
+    private readonly batchHeaders;
+    private readonly mapRequestItem;
+    private readonly exclude;
+    private pending;
+    order: number;
+    constructor(options: BatchLinkPluginOptions<T>);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface ClientRetryPluginAttemptOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    lastEventRetry: number | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: Value<number, [StandardLinkInterceptorOptions<ClientRetryPluginContext>]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [ClientRetryPluginAttemptOptions<ClientRetryPluginContext>]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions<ClientRetryPluginContext>) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+interface SimpleCsrfProtectionLinkPluginOptions<T extends ClientContext> {
+    /**
+     * The name of the header to check.
+     *
+     * @default 'x-csrf-token'
+     */
+    headerName?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * The value of the header to check.
+     *
+     * @default 'orpc'
+     *
+     */
+    headerValue?: Value<string, [options: StandardLinkClientInterceptorOptions<T>]>;
+    /**
+     * Exclude a procedure from the plugin.
+     *
+     * @default false
+     */
+    exclude?: Value<boolean, [options: StandardLinkClientInterceptorOptions<T>]>;
+}
+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;
+}
+
+export { BatchLinkPlugin, type BatchLinkPluginGroup, type BatchLinkPluginOptions, ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions, SimpleCsrfProtectionLinkPlugin, type SimpleCsrfProtectionLinkPluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,290 @@
+import { isAsyncIteratorObject, value, splitInHalf, toArray } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse } from '@orpc/standard-server/batch';
+import { getEventMeta } from '@orpc/standard-server';
+
+class BatchLinkPlugin {
+  groups;
+  maxSize;
+  batchUrl;
+  maxUrlLength;
+  batchHeaders;
+  mapRequestItem;
+  exclude;
+  pending;
+  order = 5e6;
+  constructor(options) {
+    this.groups = options.groups;
+    this.pending = /* @__PURE__ */ new Map();
+    this.maxSize = options.maxSize ?? 10;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
+    this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(options2.request.headers)) {
+        if (rest.every((item) => item.request.headers[key] === value2)) {
+          headers[key] = value2;
+        }
+      }
+      return headers;
+    });
+    this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(request.headers)) {
+        if (batchHeaders[key] !== value2) {
+          headers[key] = value2;
+        }
+      }
+      return {
+        method: request.method,
+        url: request.url,
+        headers,
+        body: request.body,
+        signal: request.signal
+      };
+    });
+    this.exclude = options.exclude ?? (() => false);
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push((options2) => {
+      if (options2.request.headers["x-orpc-batch"] !== "1") {
+        return options2.next();
+      }
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            "x-orpc-batch": void 0
+          }
+        }
+      });
+    });
+    options.clientInterceptors.push((options2) => {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+        return options2.next();
+      }
+      const group = this.groups.find((group2) => group2.condition(options2));
+      if (!group) {
+        return options2.next();
+      }
+      return new Promise((resolve, reject) => {
+        this.#enqueueRequest(group, options2, resolve, reject);
+        setTimeout(() => this.#processPendingBatches());
+      });
+    });
+  }
+  #enqueueRequest(group, options, resolve, reject) {
+    const items = this.pending.get(group);
+    if (items) {
+      items.push([options, resolve, reject]);
+    } else {
+      this.pending.set(group, [[options, resolve, reject]]);
+    }
+  }
+  async #processPendingBatches() {
+    const pending = this.pending;
+    this.pending = /* @__PURE__ */ new Map();
+    for (const [group, items] of pending) {
+      const getItems = items.filter(([options]) => options.request.method === "GET");
+      const restItems = items.filter(([options]) => options.request.method !== "GET");
+      this.#executeBatch("GET", group, getItems);
+      this.#executeBatch("POST", group, restItems);
+    }
+  }
+  async #executeBatch(method, group, groupItems) {
+    if (!groupItems.length) {
+      return;
+    }
+    const batchItems = groupItems;
+    if (batchItems.length === 1) {
+      batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
+      return;
+    }
+    try {
+      const options = batchItems.map(([options2]) => options2);
+      const maxSize = await value(this.maxSize, options);
+      if (batchItems.length > maxSize) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        this.#executeBatch(method, group, second);
+        return;
+      }
+      const batchUrl = new URL(await value(this.batchUrl, options));
+      const batchHeaders = await value(this.batchHeaders, options);
+      const mappedItems = batchItems.map(([options2]) => this.mapRequestItem({ ...options2, batchUrl, batchHeaders }));
+      const batchRequest = toBatchRequest({
+        method,
+        url: batchUrl,
+        headers: batchHeaders,
+        requests: mappedItems
+      });
+      const maxUrlLength = await value(this.maxUrlLength, options);
+      if (batchRequest.url.toString().length > maxUrlLength) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        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) });
+      }
+      throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
+    } catch (error) {
+      for (const [, , reject] of batchItems) {
+        reject(error);
+      }
+    }
+  }
+}
+
+class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+class ClientRetryPlugin {
+  defaultRetry;
+  defaultRetryDelay;
+  defaultShouldRetry;
+  defaultOnRetry;
+  constructor(options = {}) {
+    this.defaultRetry = options.default?.retry ?? 0;
+    this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
+    this.defaultShouldRetry = options.default?.shouldRetry ?? true;
+    this.defaultOnRetry = options.default?.onRetry;
+  }
+  init(options) {
+    options.interceptors ??= [];
+    options.interceptors.push(async (interceptorOptions) => {
+      const maxAttempts = await value(
+        interceptorOptions.context.retry ?? this.defaultRetry,
+        interceptorOptions
+      );
+      const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
+      if (maxAttempts <= 0) {
+        return interceptorOptions.next();
+      }
+      let lastEventId = interceptorOptions.lastEventId;
+      let lastEventRetry;
+      let unsubscribe;
+      let attemptIndex = 0;
+      const next = async (initial) => {
+        let current = initial;
+        while (true) {
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          if (current) {
+            if (attemptIndex >= maxAttempts) {
+              throw current.error;
+            }
+            const attemptOptions = {
+              ...updatedInterceptorOptions,
+              attemptIndex,
+              error: current.error,
+              lastEventRetry
+            };
+            const shouldRetryBool = await value(
+              shouldRetry,
+              attemptOptions
+            );
+            if (!shouldRetryBool) {
+              throw current.error;
+            }
+            unsubscribe = onRetry?.(attemptOptions);
+            const retryDelayMs = await value(retryDelay, attemptOptions);
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            attemptIndex++;
+          }
+          try {
+            return await interceptorOptions.next(updatedInterceptorOptions);
+          } catch (error) {
+            if (updatedInterceptorOptions.signal?.aborted === true) {
+              throw error;
+            }
+            current = { error };
+          } finally {
+            unsubscribe?.();
+            unsubscribe = void 0;
+          }
+        }
+      };
+      const output = await next();
+      if (!isAsyncIteratorObject(output)) {
+        return output;
+      }
+      return async function* () {
+        let current = output;
+        try {
+          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;
+            } catch (error) {
+              const meta = getEventMeta(error);
+              lastEventId = meta?.id ?? lastEventId;
+              lastEventRetry = meta?.retry ?? lastEventRetry;
+              const maybeEventIterator = await next({ error });
+              if (!isAsyncIteratorObject(maybeEventIterator)) {
+                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
+                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
+                );
+              }
+              current = maybeEventIterator;
+            }
+          }
+        } finally {
+          await current.return?.();
+        }
+      }();
+    });
+  }
+}
+
+class SimpleCsrfProtectionLinkPlugin {
+  headerName;
+  headerValue;
+  exclude;
+  constructor(options = {}) {
+    this.headerName = options.headerName ?? "x-csrf-token";
+    this.headerValue = options.headerValue ?? "orpc";
+    this.exclude = options.exclude ?? false;
+  }
+  order = 8e6;
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (options2) => {
+      const excluded = await value(this.exclude, options2);
+      if (excluded) {
+        return options2.next();
+      }
+      const headerName = await value(this.headerName, options2);
+      const headerValue = await value(this.headerValue, options2);
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            [headerName]: headerValue
+          }
+        }
+      });
+    });
+  }
+}
+
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };

package/dist/shared/client.2CWETx1V.d.mts

@@ -0,0 +1,47 @@
+import { Interceptor, ThrowableError } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.CipPQkhk.mjs';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkPlugin<T extends ClientContext> {
+    order?: number;
+    init?(options: StandardLinkOptions<T>): void;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext, TPlugin extends StandardLinkPlugin<T>> implements StandardLinkPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: readonly string[];
+    input: unknown;
+}
+interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    request: StandardRequest;
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[];
+    clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+export { CompositeStandardLinkPlugin as C, InvalidEventIteratorRetryResponse as I, type StandardLinkClientInterceptorOptions as S, type StandardLinkPlugin as a, type StandardLinkOptions as b, type StandardLinkInterceptorOptions as c, StandardLink as d, type StandardLinkCodec as e, type StandardLinkClient as f };