@trpc/client 11.3.1 → 11.3.2-canary.4

package/dist/index.cjs

@@ -0,0 +1,736 @@
+const require_chunk = require('./chunk-DWy1uDak.cjs');
+const require_splitLink = require('./splitLink-BMgxggng.cjs');
+const require_TRPCClientError = require('./TRPCClientError-CGgRtttT.cjs');
+const require_httpUtils = require('./httpUtils-Buf6jCgh.cjs');
+const require_httpLink = require('./httpLink-BbVj_TgM.cjs');
+const require_httpBatchLink = require('./httpBatchLink-CIC9PZ_Z.cjs');
+const require_unstable_internals = require('./unstable-internals-CYBH4jbF.cjs');
+const require_loggerLink = require('./loggerLink-CsDfg5Bb.cjs');
+const require_wsLink = require('./wsLink-DhJ50EC5.cjs');
+const __trpc_server_observable = require_chunk.__toESM(require("@trpc/server/observable"));
+const __trpc_server_unstable_core_do_not_import = require_chunk.__toESM(require("@trpc/server/unstable-core-do-not-import"));
+const __trpc_server = require_chunk.__toESM(require("@trpc/server"));
+const __trpc_server_rpc = require_chunk.__toESM(require("@trpc/server/rpc"));
+
+//#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$ = require_splitLink.createChain({
+			links: this.links,
+			op: {
+				...opts,
+				context: opts.context ?? {},
+				id: ++this.requestId
+			}
+		});
+		return chain$.pipe((0, __trpc_server_observable.share)());
+	}
+	async requestAsPromise(opts) {
+		try {
+			const req$ = this.$request(opts);
+			const envelope = await (0, __trpc_server_observable.observableToPromise)(req$);
+			const data = envelope.result.data;
+			return data;
+		} catch (err) {
+			throw require_TRPCClientError.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 = (0, __trpc_server_unstable_core_do_not_import.createRecursiveProxy)(({ path, args }) => {
+		const pathCopy = [...path];
+		const procedureType = clientCallTypeToProcedureType(pathCopy.pop());
+		const fullPath = pathCopy.join(".");
+		return client[procedureType](fullPath, ...args);
+	});
+	return (0, __trpc_server_unstable_core_do_not_import.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 = require_httpUtils.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 = require_httpUtils.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 = require_httpBatchLink.allAbortSignals(...batchOps.map((op) => op.signal));
+					const abortController = new AbortController();
+					const responsePromise = require_httpUtils.fetchHTTPResponse({
+						...resolvedOpts,
+						signal: require_httpBatchLink.raceAbortSignals(batchSignals, abortController.signal),
+						type,
+						contentTypeHeader: "application/json",
+						trpcAcceptHeader: "application/jsonl",
+						getUrl: require_httpUtils.getUrl,
+						getBody: require_httpUtils.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 (0, __trpc_server_unstable_core_do_not_import.jsonlStreamConsumer)({
+						from: res.body,
+						deserialize: resolvedOpts.transformer.output.deserialize,
+						formatError(opts$1) {
+							const error = opts$1.error;
+							return require_TRPCClientError.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 = require_httpBatchLink.dataLoader(batchLoader("query"));
+		const mutation = require_httpBatchLink.dataLoader(batchLoader("mutation"));
+		const loaders = {
+			query,
+			mutation
+		};
+		return ({ op }) => {
+			return (0, __trpc_server_observable.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(require_TRPCClientError.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(require_TRPCClientError.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 require_wsLink.resultOf(opts.url);
+	if (opts.connectionParams) {
+		const params = await require_wsLink.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 = require_unstable_internals.getTransformer(opts.transformer);
+	return () => {
+		return ({ op }) => {
+			return (0, __trpc_server_observable.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 = require_httpBatchLink.raceAbortSignals(op.signal, ac.signal);
+				const eventSourceStream = (0, __trpc_server_unstable_core_do_not_import.sseStreamConsumer)({
+					url: async () => require_httpUtils.getUrl({
+						transformer,
+						url: await urlWithConnectionParams(opts),
+						input: inputWithTrackedEventId(input, lastEventId),
+						path,
+						type,
+						signal: null
+					}),
+					init: () => require_wsLink.resultOf(opts.eventSourceOptions, { op }),
+					signal,
+					deserialize: transformer.output.deserialize,
+					EventSource: opts.EventSource ?? globalThis.EventSource
+				});
+				const connectionState = (0, __trpc_server_observable.behaviorSubject)({
+					type: "state",
+					state: "connecting",
+					error: null
+				});
+				const connectionSub = connectionState.subscribe({ next(state) {
+					observer.next({ result: state });
+				} });
+				(0, __trpc_server_unstable_core_do_not_import.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 = require_TRPCClientError.TRPCClientError.from({ error: chunk.error });
+							if (__trpc_server_unstable_core_do_not_import.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 && require_TRPCClientError.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 require_TRPCClientError.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(require_TRPCClientError.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 (0, __trpc_server_observable.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 = require_chunk.__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 = require_chunk.__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 unstable_localLink(opts) {
+	const transformer = require_unstable_internals.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 }) => (0, __trpc_server_observable.observable)((observer) => {
+		let ctx = void 0;
+		const ac = new AbortController();
+		const signal = require_httpBatchLink.raceAbortSignals(op.signal, ac.signal);
+		const signalPromise = require_httpBatchLink.abortSignalToPromise(signal);
+		signalPromise.catch(() => {});
+		let input = op.input;
+		async function runProcedure(newInput) {
+			input = newInput;
+			ctx = await opts.createContext();
+			return (0, __trpc_server_unstable_core_do_not_import.callProcedure)({
+				router: opts.router,
+				path: op.path,
+				getRawInput: async () => newInput,
+				ctx,
+				type: op.type,
+				signal
+			});
+		}
+		function onErrorCallback(cause) {
+			if ((0, __trpc_server_unstable_core_do_not_import.isAbortError)(cause)) return;
+			opts.onError?.({
+				error: (0, __trpc_server.getTRPCErrorFromUnknown)(cause),
+				type: op.type,
+				path: op.path,
+				input,
+				ctx
+			});
+		}
+		function coerceToTRPCClientError(cause) {
+			if (require_TRPCClientError.isTRPCClientError(cause)) return cause;
+			const error = (0, __trpc_server.getTRPCErrorFromUnknown)(cause);
+			const shape = (0, __trpc_server.getTRPCErrorShape)({
+				config: opts.router._def._config,
+				ctx,
+				error,
+				input,
+				path: op.path,
+				type: op.type
+			});
+			return require_TRPCClientError.TRPCClientError.from({ error: transformChunk(shape) });
+		}
+		(0, __trpc_server_unstable_core_do_not_import.run)(async () => {
+			switch (op.type) {
+				case "query":
+				case "mutation": {
+					const result = await runProcedure(op.input);
+					if (!(0, __trpc_server_unstable_core_do_not_import.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((0, __trpc_server_unstable_core_do_not_import.iteratorResource)(result));
+							const _finally = _usingCtx$1.u((0, __trpc_server_unstable_core_do_not_import.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 = (0, __trpc_server_observable.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((0, __trpc_server_unstable_core_do_not_import.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 (!(0, __trpc_server_unstable_core_do_not_import.isAsyncIterable)(result)) throw new Error("Expected an async iterable");
+						const iterator = _usingCtx4.a((0, __trpc_server_unstable_core_do_not_import.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 ((0, __trpc_server_unstable_core_do_not_import.isAbortError)(cause)) return;
+								const error = (0, __trpc_server.getTRPCErrorFromUnknown)(cause);
+								if (!__trpc_server_unstable_core_do_not_import.retryableRpcCodes.includes(__trpc_server_rpc.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 ((0, __trpc_server.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();
+		};
+	});
+}
+/**
+* @deprecated Renamed to `unstable_localLink`. This alias will be removed in a future major release.
+*/
+const experimental_localLink = unstable_localLink;
+
+//#endregion
+exports.TRPCClientError = require_TRPCClientError.TRPCClientError;
+exports.TRPCUntypedClient = TRPCUntypedClient;
+exports.clientCallTypeToProcedureType = clientCallTypeToProcedureType;
+exports.createTRPCClient = createTRPCClient;
+exports.createTRPCClientProxy = createTRPCClientProxy;
+exports.createTRPCProxyClient = createTRPCClient;
+exports.createTRPCUntypedClient = createTRPCUntypedClient;
+exports.createWSClient = require_wsLink.createWSClient;
+exports.experimental_localLink = experimental_localLink;
+exports.getFetch = require_httpUtils.getFetch;
+exports.getUntypedClient = getUntypedClient;
+exports.httpBatchLink = require_httpBatchLink.httpBatchLink;
+exports.httpBatchStreamLink = httpBatchStreamLink;
+exports.httpLink = require_httpLink.httpLink;
+exports.httpSubscriptionLink = httpSubscriptionLink;
+exports.isFormData = require_httpLink.isFormData;
+exports.isNonJsonSerializable = require_httpLink.isNonJsonSerializable;
+exports.isOctetType = require_httpLink.isOctetType;
+exports.isTRPCClientError = require_TRPCClientError.isTRPCClientError;
+exports.loggerLink = require_loggerLink.loggerLink;
+exports.retryLink = retryLink;
+exports.splitLink = require_splitLink.splitLink;
+exports.unstable_httpBatchStreamLink = unstable_httpBatchStreamLink;
+exports.unstable_httpSubscriptionLink = unstable_httpSubscriptionLink;
+exports.unstable_localLink = unstable_localLink;
+exports.wsLink = require_wsLink.wsLink;