silgi 0.0.13 → 0.1.0-beta.1

package/dist/client/adapters/ofetch/index.mjs

@@ -0,0 +1,92 @@
+import { SilgiError, fromSilgiErrorJSON, isSilgiErrorJSON } from "../../../core/error.mjs";
+import { MSGPACK_CONTENT_TYPE, decode, encode } from "../../../codec/msgpack.mjs";
+import { FetchError, ofetch } from "ofetch";
+//#region src/client/adapters/ofetch/index.ts
+/**
+* ofetch-based RPC transport — v2 client link.
+*
+* Uses ofetch for: retry, timeout, interceptors, auto-JSON.
+* Replaces manual fetch + retry/dedupe plugins with a single link.
+*/
+/**
+* Create a Silgi client link powered by ofetch.
+*
+* @example
+* ```ts
+* import { createClient } from "silgi/client"
+* import { createLink } from "silgi/client/ofetch"
+*
+* const link = createLink({ url: "http://localhost:3000" })
+* const client = createClient<AppRouter>(link)
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+function createLink(options) {
+	const baseUrl = options.url.endsWith("/") ? options.url.slice(0, -1) : options.url;
+	const defaultTimeout = options.timeout ?? 3e4;
+	const defaultRetry = options.retry;
+	const defaultRetryDelay = options.retryDelay ?? 0;
+	const binary = options.binary ?? false;
+	const useDevalue = options.devalue ?? false;
+	return { async call(path, input, callOptions) {
+		const url = `${baseUrl}/${path.map(encodeURIComponent).join("/")}`;
+		const headers = { ...typeof options.headers === "function" ? options.headers(callOptions) : options.headers };
+		let body;
+		if (binary) {
+			headers["content-type"] = MSGPACK_CONTENT_TYPE;
+			headers["accept"] = MSGPACK_CONTENT_TYPE;
+			body = input !== void 0 && input !== null ? encode(input) : void 0;
+		} else if (useDevalue) {
+			const { encode: devalueEncode, DEVALUE_CONTENT_TYPE } = await import("../../../codec/devalue.mjs");
+			headers["content-type"] = DEVALUE_CONTENT_TYPE;
+			headers["accept"] = DEVALUE_CONTENT_TYPE;
+			body = input !== void 0 && input !== null ? devalueEncode(input) : void 0;
+		} else body = input !== void 0 && input !== null ? input : void 0;
+		try {
+			const data = await ofetch(url, {
+				method: "POST",
+				headers,
+				body,
+				signal: callOptions.signal,
+				timeout: defaultTimeout,
+				retry: defaultRetry ?? 0,
+				retryDelay: defaultRetryDelay,
+				ignoreResponseError: true,
+				onRequest: options.onRequest,
+				onResponse: options.onResponse,
+				onRequestError: options.onRequestError,
+				onResponseError: options.onResponseError,
+				...binary ? { responseType: "arrayBuffer" } : useDevalue ? { responseType: "text" } : { parseResponse(text) {
+					if (!text) return void 0;
+					try {
+						return JSON.parse(text);
+					} catch {
+						return text;
+					}
+				} }
+			});
+			let decoded;
+			if (binary) decoded = decode(new Uint8Array(data));
+			else if (useDevalue) {
+				const { decode: devalueDecode } = await import("../../../codec/devalue.mjs");
+				decoded = data ? devalueDecode(data) : void 0;
+			} else decoded = data;
+			if (isSilgiErrorJSON(decoded)) throw fromSilgiErrorJSON(decoded);
+			return decoded;
+		} catch (error) {
+			if (error instanceof SilgiError) throw error;
+			if (error instanceof FetchError) {
+				const responseData = error.data;
+				if (isSilgiErrorJSON(responseData)) throw fromSilgiErrorJSON(responseData);
+				throw new SilgiError("INTERNAL_SERVER_ERROR", {
+					status: error.status ?? 500,
+					message: error.message,
+					data: responseData
+				});
+			}
+			throw error;
+		}
+	} };
+}
+//#endregion
+export { createLink };

package/dist/client/client.d.mts

@@ -0,0 +1,29 @@
+import { InferClient } from "../types.mjs";
+import { ClientContext, ClientLink } from "./types.mjs";
+
+//#region src/client/client.d.ts
+/**
+ * Create a type-safe client from a link.
+ *
+ * Accepts either a router type (auto-inferred) or a pre-inferred client type:
+ * ```ts
+ * // Recommended — pass AppRouter directly
+ * const client = createClient<AppRouter>(link)
+ *
+ * // Also works — explicit InferClient
+ * const client = createClient<InferClient<AppRouter>>(link)
+ * ```
+ */
+declare function createClient<T, TClientContext extends ClientContext = Record<never, never>>(link: ClientLink<TClientContext>): InferClient<T> extends never ? T : InferClient<T>;
+/**
+ * Safe client wrapper — returns [error, data] tuples instead of throwing.
+ */
+interface SafeResult<TOutput, TError> {
+  error: TError | null;
+  data: TOutput | undefined;
+  isError: boolean;
+  isSuccess: boolean;
+}
+declare function safe<TOutput, TError = unknown>(promise: Promise<TOutput>): Promise<SafeResult<TOutput, TError>>;
+//#endregion
+export { SafeResult, createClient, safe };

package/dist/client/client.mjs

@@ -0,0 +1,54 @@
+//#region src/client/client.ts
+/**
+* Create a type-safe client from a link.
+*
+* Accepts either a router type (auto-inferred) or a pre-inferred client type:
+* ```ts
+* // Recommended — pass AppRouter directly
+* const client = createClient<AppRouter>(link)
+*
+* // Also works — explicit InferClient
+* const client = createClient<InferClient<AppRouter>>(link)
+* ```
+*/
+function createClient(link) {
+	return createClientProxy(link, []);
+}
+function createClientProxy(link, path) {
+	const cache = /* @__PURE__ */ new Map();
+	const procedureClient = (input, options) => link.call(path, input, options ?? {});
+	return new Proxy(procedureClient, {
+		get(_target, prop) {
+			if (prop === "then") return void 0;
+			if (typeof prop !== "string") return void 0;
+			let cached = cache.get(prop);
+			if (!cached) {
+				cached = createClientProxy(link, Object.freeze([...path, prop]));
+				cache.set(prop, cached);
+			}
+			return cached;
+		},
+		apply(_target, _thisArg, args) {
+			return procedureClient(args[0], args[1]);
+		}
+	});
+}
+async function safe(promise) {
+	try {
+		return {
+			error: null,
+			data: await promise,
+			isError: false,
+			isSuccess: true
+		};
+	} catch (error) {
+		return {
+			error,
+			data: void 0,
+			isError: true,
+			isSuccess: false
+		};
+	}
+}
+//#endregion
+export { createClient, safe };

package/dist/client/dynamic-link.d.mts

@@ -0,0 +1,15 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/dynamic-link.d.ts
+type LinkSelector<TClientContext extends ClientContext = ClientContext> = (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => ClientLink<TClientContext>;
+/**
+ * A link that delegates to other links based on a selector function.
+ * The selector runs on every call, so it can use dynamic state.
+ */
+declare class DynamicLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(selector: LinkSelector<TClientContext>);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { DynamicLink, LinkSelector };

package/dist/client/dynamic-link.mjs

@@ -0,0 +1,16 @@
+//#region src/client/dynamic-link.ts
+/**
+* A link that delegates to other links based on a selector function.
+* The selector runs on every call, so it can use dynamic state.
+*/
+var DynamicLink = class {
+	#selector;
+	constructor(selector) {
+		this.#selector = selector;
+	}
+	call(path, input, options) {
+		return this.#selector(path, input, options).call(path, input, options);
+	}
+};
+//#endregion
+export { DynamicLink };

package/dist/client/index.d.mts

@@ -0,0 +1,7 @@
+import { SilgiError, SilgiErrorCode, SilgiErrorJSON, isDefinedError } from "../core/error.mjs";
+import { Client, ClientContext, ClientLink, ClientOptions, ClientRest, InferClientInputs, InferClientOutputs, NestedClient } from "./types.mjs";
+import { SafeResult, createClient, safe } from "./client.mjs";
+import { DynamicLink, LinkSelector } from "./dynamic-link.mjs";
+import { mergeClients } from "./merge.mjs";
+import { ClientInterceptors, withInterceptors } from "./interceptor.mjs";
+export { type Client, type ClientContext, type ClientInterceptors, type ClientLink, type ClientOptions, type ClientRest, DynamicLink, type InferClientInputs, type InferClientOutputs, type LinkSelector, type NestedClient, type SafeResult, SilgiError, type SilgiErrorCode, type SilgiErrorJSON, createClient, isDefinedError, mergeClients, safe, withInterceptors };

package/dist/client/index.mjs

@@ -0,0 +1,6 @@
+import { SilgiError, isDefinedError } from "../core/error.mjs";
+import { createClient, safe } from "./client.mjs";
+import { DynamicLink } from "./dynamic-link.mjs";
+import { mergeClients } from "./merge.mjs";
+import { withInterceptors } from "./interceptor.mjs";
+export { DynamicLink, SilgiError, createClient, isDefinedError, mergeClients, safe, withInterceptors };

package/dist/client/interceptor.d.mts

@@ -0,0 +1,31 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/interceptor.d.ts
+interface ClientInterceptors<TClientContext extends ClientContext = ClientContext> {
+  /** Called before every request. Can modify input or options. */
+  onRequest?: (event: {
+    path: readonly string[];
+    input: unknown;
+    options: ClientOptions<TClientContext>;
+  }) => void | Promise<void>;
+  /** Called after a successful response. */
+  onResponse?: (event: {
+    path: readonly string[];
+    input: unknown;
+    output: unknown;
+    durationMs: number;
+  }) => void | Promise<void>;
+  /** Called when a request fails. */
+  onError?: (event: {
+    path: readonly string[];
+    input: unknown;
+    error: unknown;
+  }) => void | Promise<void>;
+}
+/**
+ * Wrap a ClientLink with interceptor hooks.
+ * Returns a new link that calls the interceptors around the original.
+ */
+declare function withInterceptors<TClientContext extends ClientContext = ClientContext>(link: ClientLink<TClientContext>, interceptors: ClientInterceptors<TClientContext>): ClientLink<TClientContext>;
+//#endregion
+export { ClientInterceptors, withInterceptors };

package/dist/client/interceptor.mjs

@@ -0,0 +1,34 @@
+//#region src/client/interceptor.ts
+/**
+* Wrap a ClientLink with interceptor hooks.
+* Returns a new link that calls the interceptors around the original.
+*/
+function withInterceptors(link, interceptors) {
+	return { async call(path, input, options) {
+		if (interceptors.onRequest) await interceptors.onRequest({
+			path,
+			input,
+			options
+		});
+		const t0 = performance.now();
+		try {
+			const output = await link.call(path, input, options);
+			if (interceptors.onResponse) await interceptors.onResponse({
+				path,
+				input,
+				output,
+				durationMs: performance.now() - t0
+			});
+			return output;
+		} catch (error) {
+			if (interceptors.onError) await interceptors.onError({
+				path,
+				input,
+				error
+			});
+			throw error;
+		}
+	} };
+}
+//#endregion
+export { withInterceptors };

package/dist/client/merge.d.mts

@@ -0,0 +1,28 @@
+//#region src/client/merge.d.ts
+/**
+ * Client merging — combine multiple typed clients into one.
+ *
+ * Useful when different parts of your API live on different servers
+ * or use different transports.
+ *
+ * @example
+ * ```ts
+ * import { mergeClients } from "silgi/client"
+ *
+ * const client = mergeClients({
+ *   users: usersClient,
+ *   billing: billingClient,
+ *   analytics: analyticsClient,
+ * })
+ *
+ * await client.users.list({ limit: 10 })
+ * await client.billing.invoices()
+ * ```
+ */
+/**
+ * Merge multiple clients into a single typed object.
+ * Each key maps to a separate client — they can use different links.
+ */
+declare function mergeClients<T extends Record<string, unknown>>(clients: T): T;
+//#endregion
+export { mergeClients };

package/dist/client/merge.mjs

@@ -0,0 +1,30 @@
+//#region src/client/merge.ts
+/**
+* Client merging — combine multiple typed clients into one.
+*
+* Useful when different parts of your API live on different servers
+* or use different transports.
+*
+* @example
+* ```ts
+* import { mergeClients } from "silgi/client"
+*
+* const client = mergeClients({
+*   users: usersClient,
+*   billing: billingClient,
+*   analytics: analyticsClient,
+* })
+*
+* await client.users.list({ limit: 10 })
+* await client.billing.invoices()
+* ```
+*/
+/**
+* Merge multiple clients into a single typed object.
+* Each key maps to a separate client — they can use different links.
+*/
+function mergeClients(clients) {
+	return clients;
+}
+//#endregion
+export { mergeClients };

package/dist/client/openapi.d.mts

@@ -0,0 +1,29 @@
+import { ClientContext, ClientLink, ClientOptions } from "./types.mjs";
+
+//#region src/client/openapi.d.ts
+interface OpenAPILinkOptions {
+  /** Base URL of the API */
+  url: string;
+  /** OpenAPI 3.x specification object (parsed JSON) */
+  spec?: Record<string, unknown>;
+  /** Default headers */
+  headers?: Record<string, string> | (() => Record<string, string>);
+  /** Custom fetch implementation */
+  fetch?: typeof globalThis.fetch;
+}
+/**
+ * A ClientLink that makes REST requests to an OpenAPI endpoint.
+ *
+ * Maps procedure paths to REST paths:
+ * - `client.users.list({ limit: 10 })` → `GET /users/list?limit=10` or `POST /users/list`
+ *
+ * Without a spec, it defaults to POST requests with JSON body.
+ * With a spec, it uses the correct HTTP method and parameter placement.
+ */
+declare class OpenAPILink<TCtx extends ClientContext = ClientContext> implements ClientLink<TCtx> {
+  #private;
+  constructor(options: OpenAPILinkOptions);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TCtx>): Promise<unknown>;
+}
+//#endregion
+export { OpenAPILink, OpenAPILinkOptions };

package/dist/client/openapi.mjs

@@ -0,0 +1,89 @@
+import { SilgiError } from "../core/error.mjs";
+//#region src/client/openapi.ts
+/**
+* OpenAPI Client Link — consume any OpenAPI endpoint as a Silgi client.
+*
+* Unlike RPCLink (which uses Silgi's wire protocol), OpenAPILink sends
+* standard REST requests based on an OpenAPI spec.
+*
+* @example
+* ```ts
+* import { OpenAPILink } from "silgi/client/openapi"
+* import { createClient } from "silgi/client"
+*
+* const link = new OpenAPILink({
+*   url: "https://api.example.com",
+*   spec: await fetch("/openapi.json").then(r => r.json()),
+* })
+*
+* const client = createClient<ExternalAPI>(link)
+* const users = await client.users.list({ limit: 10 })
+* ```
+*/
+/**
+* A ClientLink that makes REST requests to an OpenAPI endpoint.
+*
+* Maps procedure paths to REST paths:
+* - `client.users.list({ limit: 10 })` → `GET /users/list?limit=10` or `POST /users/list`
+*
+* Without a spec, it defaults to POST requests with JSON body.
+* With a spec, it uses the correct HTTP method and parameter placement.
+*/
+var OpenAPILink = class {
+	#url;
+	#spec;
+	#headers;
+	#fetch;
+	constructor(options) {
+		this.#url = options.url.replace(/\/$/, "");
+		this.#spec = options.spec;
+		this.#headers = options.headers ?? {};
+		this.#fetch = options.fetch ?? globalThis.fetch;
+	}
+	async call(path, input, options) {
+		const endpoint = "/" + path.join("/");
+		const url = this.#url + endpoint;
+		const headers = {
+			"content-type": "application/json",
+			...typeof this.#headers === "function" ? this.#headers() : this.#headers
+		};
+		let method = "POST";
+		if (this.#spec) {
+			const paths = this.#spec.paths;
+			if (paths?.[endpoint]) {
+				if (paths[endpoint].get) method = "GET";
+				else if (paths[endpoint].post) method = "POST";
+				else if (paths[endpoint].put) method = "PUT";
+				else if (paths[endpoint].patch) method = "PATCH";
+				else if (paths[endpoint].delete) method = "DELETE";
+			}
+		}
+		let requestUrl = url;
+		let body;
+		if (method === "GET" || method === "HEAD") {
+			if (input && typeof input === "object") {
+				const params = new URLSearchParams();
+				for (const [k, v] of Object.entries(input)) if (v !== void 0) params.set(k, String(v));
+				const qs = params.toString();
+				if (qs) requestUrl = `${url}?${qs}`;
+			}
+		} else body = input !== void 0 ? JSON.stringify(input) : void 0;
+		const response = await this.#fetch(requestUrl, {
+			method,
+			headers,
+			body,
+			signal: options.signal
+		});
+		if (!response.ok) {
+			const errorBody = await response.json().catch(() => null);
+			throw new SilgiError(errorBody?.code ?? `HTTP_${response.status}`, {
+				status: response.status,
+				message: errorBody?.message ?? response.statusText,
+				data: errorBody
+			});
+		}
+		return response.json();
+	}
+};
+//#endregion
+export { OpenAPILink };

package/dist/client/plugins/batch.d.mts

@@ -0,0 +1,20 @@
+import { ClientContext, ClientLink, ClientOptions } from "../types.mjs";
+
+//#region src/client/plugins/batch.d.ts
+interface BatchLinkOptions {
+  /** The underlying link to send the batch through */
+  link: ClientLink;
+  /** Batch endpoint path (default: /__batch__) */
+  path?: string;
+  /** Maximum batch size (default: 20) */
+  maxSize?: number;
+  /** URL for the batch endpoint */
+  url: string | URL;
+}
+declare class BatchLink<TClientContext extends ClientContext = ClientContext> implements ClientLink<TClientContext> {
+  #private;
+  constructor(options: BatchLinkOptions);
+  call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+//#endregion
+export { BatchLink, BatchLinkOptions };

package/dist/client/plugins/batch.mjs

@@ -0,0 +1,64 @@
+//#region src/client/plugins/batch.ts
+var BatchLink = class {
+	#link;
+	#batchPath;
+	#maxSize;
+	#pending = [];
+	#scheduled = false;
+	constructor(options) {
+		this.#link = options.link;
+		this.#batchPath = options.path ?? "/__batch__";
+		this.#maxSize = options.maxSize ?? 20;
+	}
+	call(path, input, options) {
+		return new Promise((resolve, reject) => {
+			this.#pending.push({
+				path,
+				input,
+				options,
+				resolve,
+				reject
+			});
+			if (!this.#scheduled) {
+				this.#scheduled = true;
+				queueMicrotask(() => this.#flush());
+			}
+		});
+	}
+	async #flush() {
+		this.#scheduled = false;
+		const batch = this.#pending.splice(0);
+		if (batch.length === 0) return;
+		const chunks = [];
+		for (let i = 0; i < batch.length; i += this.#maxSize) chunks.push(batch.slice(i, i + this.#maxSize));
+		for (const chunk of chunks) await this.#sendChunk(chunk);
+	}
+	async #sendChunk(chunk) {
+		const batchBody = chunk.map((call) => ({
+			path: "/" + call.path.join("/"),
+			method: "POST",
+			body: call.input
+		}));
+		try {
+			const responses = await this.#link.call([this.#batchPath.slice(1)], batchBody, { signal: chunk[0]?.options.signal });
+			if (!Array.isArray(responses)) {
+				for (const call of chunk) call.reject(/* @__PURE__ */ new Error("Invalid batch response"));
+				return;
+			}
+			for (const response of responses) {
+				const call = chunk[response.index];
+				if (!call) continue;
+				if (response.status >= 400) call.reject(response.body ?? /* @__PURE__ */ new Error(`HTTP ${response.status}`));
+				else call.resolve(response.body);
+			}
+			for (let i = 0; i < chunk.length; i++) {
+				const call = chunk[i];
+				if (!responses.some((r) => r.index === i)) call.reject(/* @__PURE__ */ new Error("No response in batch"));
+			}
+		} catch (error) {
+			for (const call of chunk) call.reject(error);
+		}
+	}
+};
+//#endregion
+export { BatchLink };

package/dist/client/plugins/csrf.d.mts

@@ -0,0 +1,13 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/csrf.d.ts
+interface CSRFLinkOptions {
+  headerName?: string;
+  headerValue?: string;
+}
+/**
+ * Wrap a link to automatically inject the CSRF header on every request.
+ */
+declare function withCSRF<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: CSRFLinkOptions): ClientLink<TClientContext>;
+//#endregion
+export { CSRFLinkOptions, withCSRF };

package/dist/client/plugins/csrf.mjs

@@ -0,0 +1,20 @@
+//#region src/client/plugins/csrf.ts
+/**
+* Wrap a link to automatically inject the CSRF header on every request.
+*/
+function withCSRF(link, options = {}) {
+	const headerName = options.headerName ?? "x-csrf-token";
+	const headerValue = options.headerValue ?? "silgi";
+	return { call(path, input, callOptions) {
+		const enhancedOptions = {
+			...callOptions,
+			headers: {
+				...callOptions.headers,
+				[headerName]: headerValue
+			}
+		};
+		return link.call(path, input, enhancedOptions);
+	} };
+}
+//#endregion
+export { withCSRF };

package/dist/client/plugins/dedupe.d.mts

@@ -0,0 +1,10 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/dedupe.d.ts
+interface DedupeOptions {
+  /** Custom key function. Default: JSON.stringify(path + input) */
+  keyFn?: (path: readonly string[], input: unknown) => string;
+}
+declare function withDedupe<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: DedupeOptions): ClientLink<TClientContext>;
+//#endregion
+export { DedupeOptions, withDedupe };

package/dist/client/plugins/dedupe.mjs

@@ -0,0 +1,28 @@
+import { stringifyJSON } from "../../core/utils.mjs";
+//#region src/client/plugins/dedupe.ts
+/**
+* Dedupe Plugin — collapses identical concurrent requests into one.
+*
+* If two calls have the same path and serialized input within
+* the same microtask, only one actual request is sent.
+* All callers receive the same response.
+*/
+function withDedupe(link, options = {}) {
+	const inflight = /* @__PURE__ */ new Map();
+	const keyFn = options.keyFn ?? ((path, input) => stringifyJSON({
+		path,
+		input
+	}));
+	return { call(path, input, callOptions) {
+		const key = keyFn(path, input);
+		const existing = inflight.get(key);
+		if (existing) return existing;
+		const promise = link.call(path, input, callOptions).finally(() => {
+			inflight.delete(key);
+		});
+		inflight.set(key, promise);
+		return promise;
+	} };
+}
+//#endregion
+export { withDedupe };

package/dist/client/plugins/index.d.mts

@@ -0,0 +1,5 @@
+import { RetryOptions, withRetry } from "./retry.mjs";
+import { BatchLink, BatchLinkOptions } from "./batch.mjs";
+import { DedupeOptions, withDedupe } from "./dedupe.mjs";
+import { CSRFLinkOptions, withCSRF } from "./csrf.mjs";
+export { BatchLink, type BatchLinkOptions, type CSRFLinkOptions, type DedupeOptions, type RetryOptions, withCSRF, withDedupe, withRetry };

package/dist/client/plugins/index.mjs

@@ -0,0 +1,5 @@
+import { withRetry } from "./retry.mjs";
+import { BatchLink } from "./batch.mjs";
+import { withDedupe } from "./dedupe.mjs";
+import { withCSRF } from "./csrf.mjs";
+export { BatchLink, withCSRF, withDedupe, withRetry };

package/dist/client/plugins/retry.d.mts

@@ -0,0 +1,11 @@
+import { ClientContext, ClientLink } from "../types.mjs";
+
+//#region src/client/plugins/retry.d.ts
+interface RetryOptions {
+  maxRetries?: number;
+  retryDelay?: number | ((attempt: number) => number);
+  shouldRetry?: (error: unknown) => boolean;
+}
+declare function withRetry<TClientContext extends ClientContext>(link: ClientLink<TClientContext>, options?: RetryOptions): ClientLink<TClientContext>;
+//#endregion
+export { RetryOptions, withRetry };