@orpc/client 0.0.0-next.15d9202 → 0.0.0-next.173b319

package/dist/shared/{client.Df5pd75N.mjs → client.CAwgYDwB.mjs}

@@ -1,48 +1,25 @@
-import { intercept, isAsyncIteratorObject, value, isObject, trim, stringifyJSON } from '@orpc/shared';
-import { c as createAutoRetryEventIterator, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.XAn8cDTM.mjs';
+import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.BacCdg3F.mjs';
 import { ErrorEvent } from '@orpc/standard-server';
 
 class InvalidEventIteratorRetryResponse extends Error {
 }
 class StandardLink {
-  constructor(codec, sender, options) {
+  constructor(codec, sender, options = {}) {
     this.codec = codec;
     this.sender = sender;
-    this.eventIteratorMaxRetries = options.eventIteratorMaxRetries ?? 5;
-    this.eventIteratorRetryDelay = options.eventIteratorRetryDelay ?? ((o) => o.lastRetry ?? 1e3 * 2 ** o.retryTimes);
-    this.eventIteratorShouldRetry = options.eventIteratorShouldRetry ?? true;
-    this.interceptors = options.interceptors ?? [];
-    this.clientInterceptors = options.clientInterceptors ?? [];
+    for (const plugin of toArray(options.plugins)) {
+      plugin.init?.(options);
+    }
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
   }
-  eventIteratorMaxRetries;
-  eventIteratorRetryDelay;
-  eventIteratorShouldRetry;
   interceptors;
   clientInterceptors;
   call(path, input, options) {
     return intercept(this.interceptors, { path, input, options }, async ({ path: path2, input: input2, options: options2 }) => {
       const output = await this.#call(path2, input2, options2);
-      if (!isAsyncIteratorObject(output)) {
-        return output;
-      }
-      return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-        const maxRetries = await value(this.eventIteratorMaxRetries, reconnectOptions, options2, path2, input2);
-        if (options2.signal?.aborted || reconnectOptions.retryTimes > maxRetries) {
-          return null;
-        }
-        const shouldRetry = await value(this.eventIteratorShouldRetry, reconnectOptions, options2, path2, input2);
-        if (!shouldRetry) {
-          return null;
-        }
-        const retryDelay = await value(this.eventIteratorRetryDelay, reconnectOptions, options2, path2, input2);
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        const updatedOptions = { ...options2, lastEventId: reconnectOptions.lastEventId };
-        const maybeIterator = await this.#call(path2, input2, updatedOptions);
-        if (!isAsyncIteratorObject(maybeIterator)) {
-          throw new InvalidEventIteratorRetryResponse("Invalid Event Iterator retry response");
-        }
-        return maybeIterator;
-      }, options2.lastEventId);
+      return output;
     });
   }
   async #call(path, input, options) {
@@ -57,50 +34,74 @@ class StandardLink {
   }
 }
 
-class RPCJsonSerializer {
+const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
   serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
     if (data instanceof Blob) {
       maps.push(segments);
       blobs.push(data);
       return [data, meta, maps, blobs];
     }
     if (typeof data === "bigint") {
-      meta.push([0, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof Date) {
-      meta.push([1, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
       if (Number.isNaN(data.getTime())) {
         return [null, meta, maps, blobs];
       }
       return [data.toISOString(), meta, maps, blobs];
     }
     if (Number.isNaN(data)) {
-      meta.push([2, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
       return [null, meta, maps, blobs];
     }
     if (data instanceof URL) {
-      meta.push([4, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof RegExp) {
-      meta.push([5, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof Set) {
       const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
-      meta.push([6, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
       return result;
     }
     if (data instanceof Map) {
       const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
-      meta.push([7, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
       return result;
     }
     if (Array.isArray(data)) {
       const json = data.map((v, i) => {
         if (v === void 0) {
-          meta.push([3, [...segments, i]]);
+          meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
           return v;
         }
         return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
@@ -110,6 +111,9 @@ class RPCJsonSerializer {
     if (isObject(data)) {
       const json = {};
       for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
         json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
       }
       return [json, meta, maps, blobs];
@@ -129,38 +133,45 @@ class RPCJsonSerializer {
         currentRef[preSegment] = getBlob(i);
       });
     }
-    for (const [type, segments] of meta) {
+    for (const item of meta) {
+      const type = item[0];
       let currentRef = ref;
       let preSegment = "data";
-      segments.forEach((segment) => {
+      for (let i = 1; i < item.length; i++) {
         currentRef = currentRef[preSegment];
-        preSegment = segment;
-      });
+        preSegment = item[i];
+      }
+      for (const custom of this.customSerializers) {
+        if (custom.type === type) {
+          currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+          break;
+        }
+      }
       switch (type) {
-        case 0:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
           currentRef[preSegment] = BigInt(currentRef[preSegment]);
           break;
-        case 1:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
           currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
           break;
-        case 2:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
           currentRef[preSegment] = Number.NaN;
           break;
-        case 3:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
           currentRef[preSegment] = void 0;
           break;
-        case 4:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
           currentRef[preSegment] = new URL(currentRef[preSegment]);
           break;
-        case 5: {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
           const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
           currentRef[preSegment] = new RegExp(pattern, flags);
           break;
         }
-        case 6:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
           currentRef[preSegment] = new Set(currentRef[preSegment]);
           break;
-        case 7:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
           currentRef[preSegment] = new Map(currentRef[preSegment]);
           break;
       }
@@ -185,14 +196,23 @@ class StandardRPCLinkCodec {
   headers;
   async encode(path, input, options) {
     const expectedMethod = await value(this.expectedMethod, options, path, input);
-    const headers = await value(this.headers, options, path, input);
+    const headers = { ...await value(this.headers, options, path, input) };
     const baseUrl = await value(this.baseUrl, options, path, input);
-    const url = new URL(`${trim(baseUrl.toString(), "/")}/${path.map(encodeURIComponent).join("/")}`);
+    const url = new URL(`${baseUrl.toString().replace(/\/$/, "")}/${path.map(encodeURIComponent).join("/")}`);
+    if (options.lastEventId !== void 0) {
+      if (Array.isArray(headers["last-event-id"])) {
+        headers["last-event-id"] = [...headers["last-event-id"], options.lastEventId];
+      } else if (headers["last-event-id"] !== void 0) {
+        headers["last-event-id"] = [headers["last-event-id"], options.lastEventId];
+      } else {
+        headers["last-event-id"] = options.lastEventId;
+      }
+    }
     const serialized = this.serializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
       const maxUrlLength = await value(this.maxUrlLength, options, path, input);
       const getUrl = new URL(url);
-      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
       if (getUrl.toString().length <= maxUrlLength) {
         return {
           body: void 0,
@@ -242,8 +262,8 @@ class StandardRPCLinkCodec {
   }
 }
 
-class RPCSerializer {
-  constructor(jsonSerializer = new RPCJsonSerializer()) {
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
     this.jsonSerializer = jsonSerializer;
   }
   serialize(data) {
@@ -261,9 +281,6 @@ class RPCSerializer {
     return this.#serialize(data, true);
   }
   #serialize(data, enableFormData) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
     const meta = meta_.length === 0 ? void 0 : meta_;
     if (!enableFormData || blobs.length === 0) {
@@ -301,9 +318,6 @@ class RPCSerializer {
     return this.#deserialize(data);
   }
   #deserialize(data) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     if (!(data instanceof FormData)) {
       return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
     }
@@ -317,4 +331,4 @@ class RPCSerializer {
   }
 }
 
-export { InvalidEventIteratorRetryResponse as I, RPCJsonSerializer as R, StandardLink as S, StandardRPCLinkCodec as a, RPCSerializer as b };
+export { InvalidEventIteratorRetryResponse as I, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLinkCodec as c, StandardRPCSerializer as d };

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

@@ -0,0 +1,39 @@
+import { Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, C as ClientOptions, b as ClientLink } from './client.RZs5Myak.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>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkPlugin<T extends ClientContext> {
+    init?(options: StandardLinkOptions<T>): void;
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptions<T>;
+    }, unknown, unknown>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, unknown>[];
+    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 { InvalidEventIteratorRetryResponse as I, type StandardLinkPlugin as S, type StandardLinkOptions as a, type StandardLinkClient as b, type StandardLinkCodec as c, StandardLink as d };

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

@@ -0,0 +1,30 @@
+type ClientContext = Record<string, any>;
+type FriendlyClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+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 extends Error> = Promise<TOutput> & {
+    __error?: {
+        type: TError;
+    };
+};
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    (...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;
+type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientOptions as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ClientContext as a, ClientLink as b, ClientPromiseResult as c, ClientRest as d, Client as e };

package/dist/shared/client.RZs5Myak.d.ts

@@ -0,0 +1,30 @@
+type ClientContext = Record<string, any>;
+type FriendlyClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+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 extends Error> = Promise<TOutput> & {
+    __error?: {
+        type: TError;
+    };
+};
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
+    (...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;
+type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientOptions as C, FriendlyClientOptions as F, InferClientContext as I, NestedClient as N, ClientContext as a, ClientLink as b, ClientPromiseResult as c, ClientRest as d, Client as e };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.15d9202",
+  "version": "0.0.0-next.173b319",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
@@ -34,9 +39,9 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.15d9202",
-    "@orpc/standard-server": "0.0.0-next.15d9202",
-    "@orpc/standard-server-fetch": "0.0.0-next.15d9202"
+    "@orpc/shared": "0.0.0-next.173b319",
+    "@orpc/standard-server": "0.0.0-next.173b319",
+    "@orpc/standard-server-fetch": "0.0.0-next.173b319"
   },
   "devDependencies": {
     "zod": "^3.24.2"

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

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...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;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<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>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/shared/client.D_CzLDyB.d.ts

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...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;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<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>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };