@trpc/client 11.3.1 → 11.3.2-canary.2

package/dist/index.mjs

@@ -1,16 +1,733 @@
-export { createTRPCUntypedClient } from './createTRPCUntypedClient.mjs';
-export { clientCallTypeToProcedureType, createTRPCClient, createTRPCClientProxy, createTRPCClient as createTRPCProxyClient, getUntypedClient } from './createTRPCClient.mjs';
-export { getFetch } from './getFetch.mjs';
-export { TRPCClientError, isTRPCClientError } from './TRPCClientError.mjs';
-export { isFormData, isNonJsonSerializable, isOctetType } from './links/internals/contentTypes.mjs';
-export { httpBatchLink } from './links/httpBatchLink.mjs';
-export { httpBatchStreamLink, unstable_httpBatchStreamLink } from './links/httpBatchStreamLink.mjs';
-export { httpLink } from './links/httpLink.mjs';
-export { loggerLink } from './links/loggerLink.mjs';
-export { splitLink } from './links/splitLink.mjs';
-export { wsLink } from './links/wsLink/wsLink.mjs';
-export { httpSubscriptionLink, unstable_httpSubscriptionLink } from './links/httpSubscriptionLink.mjs';
-export { retryLink } from './links/retryLink.mjs';
-export { experimental_localLink } from './links/localLink.mjs';
-export { TRPCUntypedClient } from './internals/TRPCUntypedClient.mjs';
-export { createWSClient } from './links/wsLink/createWsClient.mjs';
+import { createChain, splitLink } from "./splitLink-BVblHq4n.mjs";
+import { TRPCClientError, isTRPCClientError } from "./TRPCClientError-COkhCKf3.mjs";
+import { fetchHTTPResponse, getBody, getFetch, getUrl, resolveHTTPLinkOptions } from "./httpUtils-3pbQzhUL.mjs";
+import { httpLink, isFormData, isNonJsonSerializable, isOctetType } from "./httpLink-9bpwQ15c.mjs";
+import { abortSignalToPromise, allAbortSignals, dataLoader, httpBatchLink, raceAbortSignals } from "./httpBatchLink-DIfnmmcu.mjs";
+import { getTransformer } from "./unstable-internals-DU4WecoG.mjs";
+import { loggerLink } from "./loggerLink-PGBSQFcR.mjs";
+import { createWSClient, resultOf, wsLink } from "./wsLink-DbSHOzlB.mjs";
+import { behaviorSubject, observable, observableToPromise, share } from "@trpc/server/observable";
+import { callProcedure, createFlatProxy, createRecursiveProxy, isAbortError, isAsyncIterable, iteratorResource, jsonlStreamConsumer, makeResource, retryableRpcCodes, run, sseStreamConsumer } from "@trpc/server/unstable-core-do-not-import";
+import { getTRPCErrorFromUnknown, getTRPCErrorShape, isTrackedEnvelope } from "@trpc/server";
+import { TRPC_ERROR_CODES_BY_KEY } from "@trpc/server/rpc";
+
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region src/internals/TRPCUntypedClient.ts
+var TRPCUntypedClient = class {
+	links;
+	runtime;
+	requestId;
+	constructor(opts) {
+		this.requestId = 0;
+		this.runtime = {};
+		this.links = opts.links.map((link) => link(this.runtime));
+	}
+	$request(opts) {
+		const chain$ = createChain({
+			links: this.links,
+			op: {
+				...opts,
+				context: opts.context ?? {},
+				id: ++this.requestId
+			}
+		});
+		return chain$.pipe(share());
+	}
+	async requestAsPromise(opts) {
+		try {
+			const req$ = this.$request(opts);
+			const envelope = await observableToPromise(req$);
+			const data = envelope.result.data;
+			return data;
+		} catch (err) {
+			throw TRPCClientError.from(err);
+		}
+	}
+	query(path, input, opts) {
+		return this.requestAsPromise({
+			type: "query",
+			path,
+			input,
+			context: opts?.context,
+			signal: opts?.signal
+		});
+	}
+	mutation(path, input, opts) {
+		return this.requestAsPromise({
+			type: "mutation",
+			path,
+			input,
+			context: opts?.context,
+			signal: opts?.signal
+		});
+	}
+	subscription(path, input, opts) {
+		const observable$ = this.$request({
+			type: "subscription",
+			path,
+			input,
+			context: opts.context,
+			signal: opts.signal
+		});
+		return observable$.subscribe({
+			next(envelope) {
+				switch (envelope.result.type) {
+					case "state": {
+						opts.onConnectionStateChange?.(envelope.result);
+						break;
+					}
+					case "started": {
+						opts.onStarted?.({ context: envelope.context });
+						break;
+					}
+					case "stopped": {
+						opts.onStopped?.();
+						break;
+					}
+					case "data":
+					case void 0: {
+						opts.onData?.(envelope.result.data);
+						break;
+					}
+				}
+			},
+			error(err) {
+				opts.onError?.(err);
+			},
+			complete() {
+				opts.onComplete?.();
+			}
+		});
+	}
+};
+
+//#endregion
+//#region src/createTRPCUntypedClient.ts
+function createTRPCUntypedClient(opts) {
+	return new TRPCUntypedClient(opts);
+}
+
+//#endregion
+//#region src/createTRPCClient.ts
+const untypedClientSymbol = Symbol.for("trpc_untypedClient");
+const clientCallTypeMap = {
+	query: "query",
+	mutate: "mutation",
+	subscribe: "subscription"
+};
+/** @internal */
+const clientCallTypeToProcedureType = (clientCallType) => {
+	return clientCallTypeMap[clientCallType];
+};
+/**
+* @internal
+*/
+function createTRPCClientProxy(client) {
+	const proxy = createRecursiveProxy(({ path, args }) => {
+		const pathCopy = [...path];
+		const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+		const fullPath = pathCopy.join(".");
+		return client[procedureType](fullPath, ...args);
+	});
+	return createFlatProxy((key) => {
+		if (key === untypedClientSymbol) return client;
+		return proxy[key];
+	});
+}
+function createTRPCClient(opts) {
+	const client = new TRPCUntypedClient(opts);
+	const proxy = createTRPCClientProxy(client);
+	return proxy;
+}
+/**
+* Get an untyped client from a proxy client
+* @internal
+*/
+function getUntypedClient(client) {
+	return client[untypedClientSymbol];
+}
+
+//#endregion
+//#region src/links/httpBatchStreamLink.ts
+/**
+* @see https://trpc.io/docs/client/links/httpBatchStreamLink
+*/
+function httpBatchStreamLink(opts) {
+	const resolvedOpts = resolveHTTPLinkOptions(opts);
+	const maxURLLength = opts.maxURLLength ?? Infinity;
+	const maxItems = opts.maxItems ?? Infinity;
+	return () => {
+		const batchLoader = (type) => {
+			return {
+				validate(batchOps) {
+					if (maxURLLength === Infinity && maxItems === Infinity) return true;
+					if (batchOps.length > maxItems) return false;
+					const path = batchOps.map((op) => op.path).join(",");
+					const inputs = batchOps.map((op) => op.input);
+					const url = getUrl({
+						...resolvedOpts,
+						type,
+						path,
+						inputs,
+						signal: null
+					});
+					return url.length <= maxURLLength;
+				},
+				async fetch(batchOps) {
+					const path = batchOps.map((op) => op.path).join(",");
+					const inputs = batchOps.map((op) => op.input);
+					const batchSignals = allAbortSignals(...batchOps.map((op) => op.signal));
+					const abortController = new AbortController();
+					const responsePromise = fetchHTTPResponse({
+						...resolvedOpts,
+						signal: raceAbortSignals(batchSignals, abortController.signal),
+						type,
+						contentTypeHeader: "application/json",
+						trpcAcceptHeader: "application/jsonl",
+						getUrl,
+						getBody,
+						inputs,
+						path,
+						headers() {
+							if (!opts.headers) return {};
+							if (typeof opts.headers === "function") return opts.headers({ opList: batchOps });
+							return opts.headers;
+						}
+					});
+					const res = await responsePromise;
+					const [head] = await jsonlStreamConsumer({
+						from: res.body,
+						deserialize: resolvedOpts.transformer.output.deserialize,
+						formatError(opts$1) {
+							const error = opts$1.error;
+							return TRPCClientError.from({ error });
+						},
+						abortController
+					});
+					const promises = Object.keys(batchOps).map(async (key) => {
+						let json = await Promise.resolve(head[key]);
+						if ("result" in json) {
+							/**
+							* Not very pretty, but we need to unwrap nested data as promises
+							* Our stream producer will only resolve top-level async values or async values that are directly nested in another async value
+							*/
+							const result = await Promise.resolve(json.result);
+							json = { result: { data: await Promise.resolve(result.data) } };
+						}
+						return {
+							json,
+							meta: { response: res }
+						};
+					});
+					return promises;
+				}
+			};
+		};
+		const query = dataLoader(batchLoader("query"));
+		const mutation = dataLoader(batchLoader("mutation"));
+		const loaders = {
+			query,
+			mutation
+		};
+		return ({ op }) => {
+			return observable((observer) => {
+				/* istanbul ignore if -- @preserve */
+				if (op.type === "subscription") throw new Error("Subscriptions are unsupported by `httpBatchStreamLink` - use `httpSubscriptionLink` or `wsLink`");
+				const loader = loaders[op.type];
+				const promise = loader.load(op);
+				let _res = void 0;
+				promise.then((res) => {
+					_res = res;
+					if ("error" in res.json) {
+						observer.error(TRPCClientError.from(res.json, { meta: res.meta }));
+						return;
+					} else if ("result" in res.json) {
+						observer.next({
+							context: res.meta,
+							result: res.json.result
+						});
+						observer.complete();
+						return;
+					}
+					observer.complete();
+				}).catch((err) => {
+					observer.error(TRPCClientError.from(err, { meta: _res?.meta }));
+				});
+				return () => {};
+			});
+		};
+	};
+}
+/**
+* @deprecated use {@link httpBatchStreamLink} instead
+*/
+const unstable_httpBatchStreamLink = httpBatchStreamLink;
+
+//#endregion
+//#region src/internals/inputWithTrackedEventId.ts
+function inputWithTrackedEventId(input, lastEventId) {
+	if (!lastEventId) return input;
+	if (input != null && typeof input !== "object") return input;
+	return {
+		...input ?? {},
+		lastEventId
+	};
+}
+
+//#endregion
+//#region src/links/httpSubscriptionLink.ts
+async function urlWithConnectionParams(opts) {
+	let url = await resultOf(opts.url);
+	if (opts.connectionParams) {
+		const params = await resultOf(opts.connectionParams);
+		const prefix = url.includes("?") ? "&" : "?";
+		url += prefix + "connectionParams=" + encodeURIComponent(JSON.stringify(params));
+	}
+	return url;
+}
+/**
+* @see https://trpc.io/docs/client/links/httpSubscriptionLink
+*/
+function httpSubscriptionLink(opts) {
+	const transformer = getTransformer(opts.transformer);
+	return () => {
+		return ({ op }) => {
+			return observable((observer) => {
+				const { type, path, input } = op;
+				/* istanbul ignore if -- @preserve */
+				if (type !== "subscription") throw new Error("httpSubscriptionLink only supports subscriptions");
+				let lastEventId = void 0;
+				const ac = new AbortController();
+				const signal = raceAbortSignals(op.signal, ac.signal);
+				const eventSourceStream = sseStreamConsumer({
+					url: async () => getUrl({
+						transformer,
+						url: await urlWithConnectionParams(opts),
+						input: inputWithTrackedEventId(input, lastEventId),
+						path,
+						type,
+						signal: null
+					}),
+					init: () => resultOf(opts.eventSourceOptions, { op }),
+					signal,
+					deserialize: transformer.output.deserialize,
+					EventSource: opts.EventSource ?? globalThis.EventSource
+				});
+				const connectionState = behaviorSubject({
+					type: "state",
+					state: "connecting",
+					error: null
+				});
+				const connectionSub = connectionState.subscribe({ next(state) {
+					observer.next({ result: state });
+				} });
+				run(async () => {
+					for await (const chunk of eventSourceStream) switch (chunk.type) {
+						case "ping": break;
+						case "data":
+							const chunkData = chunk.data;
+							let result;
+							if (chunkData.id) {
+								lastEventId = chunkData.id;
+								result = {
+									id: chunkData.id,
+									data: chunkData
+								};
+							} else result = { data: chunkData.data };
+							observer.next({
+								result,
+								context: { eventSource: chunk.eventSource }
+							});
+							break;
+						case "connected": {
+							observer.next({
+								result: { type: "started" },
+								context: { eventSource: chunk.eventSource }
+							});
+							connectionState.next({
+								type: "state",
+								state: "pending",
+								error: null
+							});
+							break;
+						}
+						case "serialized-error": {
+							const error = TRPCClientError.from({ error: chunk.error });
+							if (retryableRpcCodes.includes(chunk.error.code)) {
+								connectionState.next({
+									type: "state",
+									state: "connecting",
+									error
+								});
+								break;
+							}
+							throw error;
+						}
+						case "connecting": {
+							const lastState = connectionState.get();
+							const error = chunk.event && TRPCClientError.from(chunk.event);
+							if (!error && lastState.state === "connecting") break;
+							connectionState.next({
+								type: "state",
+								state: "connecting",
+								error
+							});
+							break;
+						}
+						case "timeout": connectionState.next({
+							type: "state",
+							state: "connecting",
+							error: new TRPCClientError(`Timeout of ${chunk.ms}ms reached while waiting for a response`)
+						});
+					}
+					observer.next({ result: { type: "stopped" } });
+					connectionState.next({
+						type: "state",
+						state: "idle",
+						error: null
+					});
+					observer.complete();
+				}).catch((error) => {
+					observer.error(TRPCClientError.from(error));
+				});
+				return () => {
+					observer.complete();
+					ac.abort();
+					connectionSub.unsubscribe();
+				};
+			});
+		};
+	};
+}
+/**
+* @deprecated use {@link httpSubscriptionLink} instead
+*/
+const unstable_httpSubscriptionLink = httpSubscriptionLink;
+
+//#endregion
+//#region src/links/retryLink.ts
+/**
+* @see https://trpc.io/docs/v11/client/links/retryLink
+*/
+function retryLink(opts) {
+	return () => {
+		return (callOpts) => {
+			return observable((observer) => {
+				let next$;
+				let callNextTimeout = void 0;
+				let lastEventId = void 0;
+				attempt(1);
+				function opWithLastEventId() {
+					const op = callOpts.op;
+					if (!lastEventId) return op;
+					return {
+						...op,
+						input: inputWithTrackedEventId(op.input, lastEventId)
+					};
+				}
+				function attempt(attempts) {
+					const op = opWithLastEventId();
+					next$ = callOpts.next(op).subscribe({
+						error(error) {
+							const shouldRetry = opts.retry({
+								op,
+								attempts,
+								error
+							});
+							if (!shouldRetry) {
+								observer.error(error);
+								return;
+							}
+							const delayMs = opts.retryDelayMs?.(attempts) ?? 0;
+							if (delayMs <= 0) {
+								attempt(attempts + 1);
+								return;
+							}
+							callNextTimeout = setTimeout(() => attempt(attempts + 1), delayMs);
+						},
+						next(envelope) {
+							if ((!envelope.result.type || envelope.result.type === "data") && envelope.result.id) lastEventId = envelope.result.id;
+							observer.next(envelope);
+						},
+						complete() {
+							observer.complete();
+						}
+					});
+				}
+				return () => {
+					next$.unsubscribe();
+					clearTimeout(callNextTimeout);
+				};
+			});
+		};
+	};
+}
+
+//#endregion
+//#region ../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js
+var require_usingCtx = __commonJS({ "../../node_modules/.pnpm/@oxc-project+runtime@0.72.2/node_modules/@oxc-project/runtime/src/helpers/usingCtx.js"(exports, module) {
+	function _usingCtx() {
+		var r = "function" == typeof SuppressedError ? SuppressedError : function(r$1, e$1) {
+			var n$1 = Error();
+			return n$1.name = "SuppressedError", n$1.error = r$1, n$1.suppressed = e$1, n$1;
+		}, e = {}, n = [];
+		function using(r$1, e$1) {
+			if (null != e$1) {
+				if (Object(e$1) !== e$1) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+				if (r$1) var o = e$1[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+				if (void 0 === o && (o = e$1[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r$1)) var t = o;
+				if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+				t && (o = function o$1() {
+					try {
+						t.call(e$1);
+					} catch (r$2) {
+						return Promise.reject(r$2);
+					}
+				}), n.push({
+					v: e$1,
+					d: o,
+					a: r$1
+				});
+			} else r$1 && n.push({
+				d: e$1,
+				a: r$1
+			});
+			return e$1;
+		}
+		return {
+			e,
+			u: using.bind(null, !1),
+			a: using.bind(null, !0),
+			d: function d() {
+				var o, t = this.e, s = 0;
+				function next() {
+					for (; o = n.pop();) try {
+						if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+						if (o.d) {
+							var r$1 = o.d.call(o.v);
+							if (o.a) return s |= 2, Promise.resolve(r$1).then(next, err);
+						} else s |= 1;
+					} catch (r$2) {
+						return err(r$2);
+					}
+					if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+					if (t !== e) throw t;
+				}
+				function err(n$1) {
+					return t = t !== e ? new r(n$1, t) : n$1, next();
+				}
+				return next();
+			}
+		};
+	}
+	module.exports = _usingCtx, module.exports.__esModule = true, module.exports["default"] = module.exports;
+} });
+
+//#endregion
+//#region src/links/localLink.ts
+var import_usingCtx = __toESM(require_usingCtx(), 1);
+/**
+* localLink is a terminating link that allows you to make tRPC procedure calls directly in your application without going through HTTP.
+*
+* @see https://trpc.io/docs/links/localLink
+*/
+function experimental_localLink(opts) {
+	const transformer = getTransformer(opts.transformer);
+	const transformChunk = (chunk) => {
+		if (opts.transformer) return chunk;
+		if (chunk === void 0) return chunk;
+		const serialized = JSON.stringify(transformer.input.serialize(chunk));
+		const deserialized = JSON.parse(transformer.output.deserialize(serialized));
+		return deserialized;
+	};
+	return () => ({ op }) => observable((observer) => {
+		let ctx = void 0;
+		const ac = new AbortController();
+		const signal = raceAbortSignals(op.signal, ac.signal);
+		const signalPromise = abortSignalToPromise(signal);
+		signalPromise.catch(() => {});
+		let input = op.input;
+		async function runProcedure(newInput) {
+			input = newInput;
+			ctx = await opts.createContext();
+			return callProcedure({
+				router: opts.router,
+				path: op.path,
+				getRawInput: async () => newInput,
+				ctx,
+				type: op.type,
+				signal
+			});
+		}
+		function onErrorCallback(cause) {
+			if (isAbortError(cause)) return;
+			opts.onError?.({
+				error: getTRPCErrorFromUnknown(cause),
+				type: op.type,
+				path: op.path,
+				input,
+				ctx
+			});
+		}
+		function coerceToTRPCClientError(cause) {
+			if (isTRPCClientError(cause)) return cause;
+			const error = getTRPCErrorFromUnknown(cause);
+			const shape = getTRPCErrorShape({
+				config: opts.router._def._config,
+				ctx,
+				error,
+				input,
+				path: op.path,
+				type: op.type
+			});
+			return TRPCClientError.from({ error: transformChunk(shape) });
+		}
+		run(async () => {
+			switch (op.type) {
+				case "query":
+				case "mutation": {
+					const result = await runProcedure(op.input);
+					if (!isAsyncIterable(result)) {
+						observer.next({ result: { data: transformChunk(result) } });
+						observer.complete();
+						break;
+					}
+					observer.next({ result: { data: async function* () {
+						try {
+							var _usingCtx$1 = (0, import_usingCtx.default)();
+							const iterator = _usingCtx$1.a(iteratorResource(result));
+							const _finally = _usingCtx$1.u(makeResource({}, () => {
+								observer.complete();
+							}));
+							try {
+								while (true) {
+									const res = await Promise.race([iterator.next(), signalPromise]);
+									if (res.done) return transformChunk(res.value);
+									yield transformChunk(res.value);
+								}
+							} catch (cause) {
+								onErrorCallback(cause);
+								throw coerceToTRPCClientError(cause);
+							}
+						} catch (_) {
+							_usingCtx$1.e = _;
+						} finally {
+							await _usingCtx$1.d();
+						}
+					}() } });
+					break;
+				}
+				case "subscription": try {
+					var _usingCtx3 = (0, import_usingCtx.default)();
+					const connectionState = behaviorSubject({
+						type: "state",
+						state: "connecting",
+						error: null
+					});
+					const connectionSub = connectionState.subscribe({ next(state) {
+						observer.next({ result: state });
+					} });
+					let lastEventId = void 0;
+					const _finally = _usingCtx3.u(makeResource({}, async () => {
+						observer.complete();
+						connectionState.next({
+							type: "state",
+							state: "idle",
+							error: null
+						});
+						connectionSub.unsubscribe();
+					}));
+					while (true) try {
+						var _usingCtx4 = (0, import_usingCtx.default)();
+						const result = await runProcedure(inputWithTrackedEventId(op.input, lastEventId));
+						if (!isAsyncIterable(result)) throw new Error("Expected an async iterable");
+						const iterator = _usingCtx4.a(iteratorResource(result));
+						observer.next({ result: { type: "started" } });
+						connectionState.next({
+							type: "state",
+							state: "pending",
+							error: null
+						});
+						while (true) {
+							let res;
+							try {
+								res = await Promise.race([iterator.next(), signalPromise]);
+							} catch (cause) {
+								if (isAbortError(cause)) return;
+								const error = getTRPCErrorFromUnknown(cause);
+								if (!retryableRpcCodes.includes(TRPC_ERROR_CODES_BY_KEY[error.code])) throw coerceToTRPCClientError(error);
+								onErrorCallback(error);
+								connectionState.next({
+									type: "state",
+									state: "connecting",
+									error: coerceToTRPCClientError(error)
+								});
+								break;
+							}
+							if (res.done) return;
+							let chunk;
+							if (isTrackedEnvelope(res.value)) {
+								lastEventId = res.value[0];
+								chunk = {
+									id: res.value[0],
+									data: {
+										id: res.value[0],
+										data: res.value[1]
+									}
+								};
+							} else chunk = { data: res.value };
+							observer.next({ result: {
+								...chunk,
+								data: transformChunk(chunk.data)
+							} });
+						}
+					} catch (_) {
+						_usingCtx4.e = _;
+					} finally {
+						await _usingCtx4.d();
+					}
+					break;
+				} catch (_) {
+					_usingCtx3.e = _;
+				} finally {
+					_usingCtx3.d();
+				}
+			}
+		}).catch((cause) => {
+			onErrorCallback(cause);
+			observer.error(coerceToTRPCClientError(cause));
+		});
+		return () => {
+			ac.abort();
+		};
+	});
+}
+
+//#endregion
+export { TRPCClientError, TRPCUntypedClient, clientCallTypeToProcedureType, createTRPCClient, createTRPCClientProxy, createTRPCClient as createTRPCProxyClient, createTRPCUntypedClient, createWSClient, experimental_localLink, getFetch, getUntypedClient, httpBatchLink, httpBatchStreamLink, httpLink, httpSubscriptionLink, isFormData, isNonJsonSerializable, isOctetType, isTRPCClientError, loggerLink, retryLink, splitLink, unstable_httpBatchStreamLink, unstable_httpSubscriptionLink, wsLink };
+//# sourceMappingURL=index.mjs.map