@trpc/client 11.0.0-next.91 → 11.0.0-rc.329

package/src/links/httpBatchLink.ts

@@ -1,13 +1,14 @@
-import { NonEmptyArray } from '../internals/types';
-import { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';
-import {
-  createHTTPBatchLink,
-  RequesterFn,
-} from './internals/createHTTPBatchLink';
+import type { AnyRootTypes } from '@trpc/server/unstable-core-do-not-import';
+import type { NonEmptyArray } from '../internals/types';
+import type { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';
+import type { RequesterFn } from './internals/createHTTPBatchLink';
+import { createHTTPBatchLink } from './internals/createHTTPBatchLink';
 import { jsonHttpRequester } from './internals/httpUtils';
-import { Operation } from './types';
+import type { Operation } from './types';
 
-const batchRequester: RequesterFn<HTTPBatchLinkOptions> = (requesterOpts) => {
+const batchRequester: RequesterFn<HTTPBatchLinkOptions<AnyRootTypes>> = (
+  requesterOpts,
+) => {
   return (batchOps) => {
     const path = batchOps.map((op) => op.path).join(',');
     const inputs = batchOps.map((op) => op.input);

package/src/links/httpBatchStreamLink.ts

@@ -1,24 +1,24 @@
-import { NonEmptyArray } from '../internals/types';
-import { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';
-import {
-  createHTTPBatchLink,
-  RequesterFn,
-} from './internals/createHTTPBatchLink';
+import type { AnyRootTypes } from '@trpc/server/unstable-core-do-not-import';
+import type { NonEmptyArray } from '../internals/types';
+import type { HTTPBatchLinkOptions } from './HTTPBatchLinkOptions';
+import type { RequesterFn } from './internals/createHTTPBatchLink';
+import { createHTTPBatchLink } from './internals/createHTTPBatchLink';
 import { getTextDecoder } from './internals/getTextDecoder';
 import { streamingJsonHttpRequester } from './internals/parseJSONStream';
-import { TextDecoderEsque } from './internals/streamingUtils';
-import { Operation } from './types';
+import type { TextDecoderEsque } from './internals/streamingUtils';
+import type { Operation } from './types';
 
-export interface HTTPBatchStreamLinkOptions extends HTTPBatchLinkOptions {
-  /**
-   * Will default to the webAPI `TextDecoder`,
-   * but you can use this option if your client
-   * runtime doesn't provide it.
-   */
-  textDecoder?: TextDecoderEsque;
-}
+export type HTTPBatchStreamLinkOptions<TRoot extends AnyRootTypes> =
+  HTTPBatchLinkOptions<TRoot> & {
+    /**
+     * Will default to the webAPI `TextDecoder`,
+     * but you can use this option if your client
+     * runtime doesn't provide it.
+     */
+    textDecoder?: TextDecoderEsque;
+  };
 
-const streamRequester: RequesterFn<HTTPBatchStreamLinkOptions> = (
+const streamRequester: RequesterFn<HTTPBatchStreamLinkOptions<AnyRootTypes>> = (
   requesterOpts,
 ) => {
   const textDecoder = getTextDecoder(requesterOpts.opts.textDecoder);

package/src/links/httpFormDataLink.ts

@@ -1,15 +1,6 @@
 import { httpLinkFactory } from './httpLink';
-import { GetBody, httpRequest, Requester } from './internals/httpUtils';
-
-const getBody: GetBody = (opts) => {
-  if (!('input' in opts)) {
-    return undefined;
-  }
-  if (!(opts.input instanceof FormData)) {
-    throw new Error('Input is not FormData');
-  }
-  return opts.input;
-};
+import type { Requester } from './internals/httpUtils';
+import { httpRequest } from './internals/httpUtils';
 
 const formDataRequester: Requester = (opts) => {
   if (opts.type !== 'mutation') {
@@ -21,7 +12,15 @@ const formDataRequester: Requester = (opts) => {
     getUrl() {
       return `${opts.url}/${opts.path}`;
     },
-    getBody,
+    getBody(opts) {
+      if (!('input' in opts)) {
+        return undefined;
+      }
+      if (!(opts.input instanceof FormData)) {
+        throw new Error('Input is not FormData');
+      }
+      return opts.input;
+    },
   });
 };
 

package/src/links/httpLink.ts

@@ -1,39 +1,44 @@
-import { AnyRouter } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
-import { transformResult } from '../shared/transformResult';
+import type {
+  AnyRootTypes,
+  AnyRouter,
+} from '@trpc/server/unstable-core-do-not-import';
+import { transformResult } from '@trpc/server/unstable-core-do-not-import';
 import { TRPCClientError } from '../TRPCClientError';
-import {
+import type {
   HTTPLinkBaseOptions,
   HTTPResult,
-  jsonHttpRequester,
   Requester,
+} from './internals/httpUtils';
+import {
+  jsonHttpRequester,
   resolveHTTPLinkOptions,
 } from './internals/httpUtils';
-import { HTTPHeaders, Operation, TRPCLink } from './types';
+import type { HTTPHeaders, Operation, TRPCLink } from './types';
 
-export interface HTTPLinkOptions extends HTTPLinkBaseOptions {
-  /**
-   * Headers to be set on outgoing requests or a callback that of said headers
-   * @link http://trpc.io/docs/client/headers
-   */
-  headers?:
-    | HTTPHeaders
-    | ((opts: { op: Operation }) => HTTPHeaders | Promise<HTTPHeaders>);
-}
+export type HTTPLinkOptions<TRoot extends AnyRootTypes> =
+  HTTPLinkBaseOptions<TRoot> & {
+    /**
+     * Headers to be set on outgoing requests or a callback that of said headers
+     * @link http://trpc.io/docs/client/headers
+     */
+    headers?:
+      | HTTPHeaders
+      | ((opts: { op: Operation }) => HTTPHeaders | Promise<HTTPHeaders>);
+  };
 
 export function httpLinkFactory(factoryOpts: { requester: Requester }) {
   return <TRouter extends AnyRouter>(
-    opts: HTTPLinkOptions,
+    opts: HTTPLinkOptions<TRouter['_def']['_config']['$types']>,
   ): TRPCLink<TRouter> => {
     const resolvedOpts = resolveHTTPLinkOptions(opts);
 
-    return (runtime) =>
+    return () =>
       ({ op }) =>
         observable((observer) => {
           const { path, input, type } = op;
           const { promise, cancel } = factoryOpts.requester({
             ...resolvedOpts,
-            runtime,
             type,
             path,
             input,
@@ -53,7 +58,10 @@ export function httpLinkFactory(factoryOpts: { requester: Requester }) {
           promise
             .then((res) => {
               meta = res.meta;
-              const transformed = transformResult(res.json, runtime);
+              const transformed = transformResult(
+                res.json,
+                resolvedOpts.transformer.output,
+              );
 
               if (!transformed.ok) {
                 observer.error(
@@ -81,6 +89,6 @@ export function httpLinkFactory(factoryOpts: { requester: Requester }) {
 }
 
 /**
- * @see https://trpc.io/docs/client/links/httpLink
+ * @link https://trpc.io/docs/v11/client/links/httpLink
  */
 export const httpLink = httpLinkFactory({ requester: jsonHttpRequester });

package/src/links/internals/createChain.ts

@@ -1,6 +1,10 @@
-import { AnyRouter } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
-import { Operation, OperationLink, OperationResultObservable } from '../types';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import type {
+  Operation,
+  OperationLink,
+  OperationResultObservable,
+} from '../types';
 
 /** @internal */
 export function createChain<

package/src/links/internals/createHTTPBatchLink.ts

@@ -1,21 +1,27 @@
-import { AnyRouter, ProcedureType } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
+import type {
+  AnyRootTypes,
+  AnyRouter,
+  inferClientTypes,
+  ProcedureType,
+} from '@trpc/server/unstable-core-do-not-import';
+import { transformResult } from '@trpc/server/unstable-core-do-not-import';
 import { dataLoader } from '../../internals/dataLoader';
-import { transformResult } from '../../shared/transformResult';
 import { TRPCClientError } from '../../TRPCClientError';
-import { HTTPBatchLinkOptions } from '../HTTPBatchLinkOptions';
-import { CancelFn, Operation, TRPCClientRuntime, TRPCLink } from '../types';
-import {
-  getUrl,
-  HTTPResult,
-  ResolvedHTTPLinkOptions,
-  resolveHTTPLinkOptions,
-} from './httpUtils';
+import type { HTTPBatchLinkOptions } from '../HTTPBatchLinkOptions';
+import type {
+  CancelFn,
+  Operation,
+  TRPCClientRuntime,
+  TRPCLink,
+} from '../types';
+import type { HTTPResult, ResolvedHTTPLinkOptions } from './httpUtils';
+import { getUrl, resolveHTTPLinkOptions } from './httpUtils';
 
 /**
  * @internal
  */
-export type RequesterFn<TOptions extends HTTPBatchLinkOptions> = (
+export type RequesterFn<TOptions extends HTTPBatchLinkOptions<AnyRootTypes>> = (
   requesterOpts: ResolvedHTTPLinkOptions & {
     runtime: TRPCClientRuntime;
     type: ProcedureType;
@@ -32,11 +38,11 @@ export type RequesterFn<TOptions extends HTTPBatchLinkOptions> = (
 /**
  * @internal
  */
-export function createHTTPBatchLink<TOptions extends HTTPBatchLinkOptions>(
-  requester: RequesterFn<TOptions>,
+export function createHTTPBatchLink(
+  requester: RequesterFn<HTTPBatchLinkOptions<AnyRootTypes>>,
 ) {
   return function httpBatchLink<TRouter extends AnyRouter>(
-    opts: TOptions,
+    opts: HTTPBatchLinkOptions<inferClientTypes<TRouter>>,
   ): TRPCLink<TRouter> {
     const resolvedOpts = resolveHTTPLinkOptions(opts);
     const maxURLLength = opts.maxURLLength ?? Infinity;
@@ -54,7 +60,6 @@ export function createHTTPBatchLink<TOptions extends HTTPBatchLinkOptions>(
 
           const url = getUrl({
             ...resolvedOpts,
-            runtime,
             type,
             path,
             inputs,
@@ -91,7 +96,10 @@ export function createHTTPBatchLink<TOptions extends HTTPBatchLinkOptions>(
           promise
             .then((res) => {
               _res = res;
-              const transformed = transformResult(res.json, runtime);
+              const transformed = transformResult(
+                res.json,
+                resolvedOpts.transformer.output,
+              );
 
               if (!transformed.ok) {
                 observer.error(

package/src/links/internals/dedupeLink.ts

@@ -1,8 +1,9 @@
 /* istanbul ignore file -- @preserve */
 // We're not actually exporting this link
-import { AnyRouter } from '@trpc/server';
-import { Observable, observable, share } from '@trpc/server/observable';
-import { TRPCLink } from '../types';
+import type { Observable } from '@trpc/server/observable';
+import { observable, share } from '@trpc/server/observable';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import type { TRPCLink } from '../types';
 
 /**
  * @internal used for testing

package/src/links/internals/getTextDecoder.ts

@@ -1,4 +1,4 @@
-import { TextDecoderEsque } from './streamingUtils';
+import type { TextDecoderEsque } from './streamingUtils';
 
 export function getTextDecoder(
   customTextDecoder?: TextDecoderEsque,

package/src/links/internals/httpUtils.ts

@@ -1,8 +1,12 @@
-import { ProcedureType } from '@trpc/server';
-import { TRPCResponse } from '@trpc/server/rpc';
+import type {
+  AnyRootTypes,
+  CombinedDataTransformer,
+  ProcedureType,
+  TRPCResponse,
+} from '@trpc/server/unstable-core-do-not-import';
 import { getFetch } from '../../getFetch';
 import { getAbortController } from '../../internals/getAbortController';
-import {
+import type {
   AbortControllerEsque,
   AbortControllerInstanceEsque,
   FetchEsque,
@@ -10,13 +14,17 @@ import {
   ResponseEsque,
 } from '../../internals/types';
 import { TRPCClientError } from '../../TRPCClientError';
-import { TextDecoderEsque } from '../internals/streamingUtils';
-import { HTTPHeaders, PromiseAndCancel, TRPCClientRuntime } from '../types';
+import type { TransformerOptions } from '../../unstable-internals';
+import { getTransformer } from '../../unstable-internals';
+import type { TextDecoderEsque } from '../internals/streamingUtils';
+import type { HTTPHeaders, PromiseAndCancel } from '../types';
 
 /**
  * @internal
  */
-export interface HTTPLinkBaseOptions {
+export type HTTPLinkBaseOptions<
+  TRoot extends Pick<AnyRootTypes, 'transformer'>,
+> = {
   url: string | URL;
   /**
    * Add ponyfill for fetch
@@ -26,21 +34,31 @@ export interface HTTPLinkBaseOptions {
    * Add ponyfill for AbortController
    */
   AbortController?: AbortControllerEsque | null;
-}
+  /**
+   * Send all requests `as POST`s requests regardless of the procedure type
+   * The HTTP handler must separately allow overriding the method. See:
+   * @link https://trpc.io/docs/rpc
+   */
+  methodOverride?: 'POST';
+} & TransformerOptions<TRoot>;
 
 export interface ResolvedHTTPLinkOptions {
   url: string;
   fetch?: FetchEsque;
   AbortController: AbortControllerEsque | null;
+  transformer: CombinedDataTransformer;
+  methodOverride?: 'POST';
 }
 
 export function resolveHTTPLinkOptions(
-  opts: HTTPLinkBaseOptions,
+  opts: HTTPLinkBaseOptions<AnyRootTypes>,
 ): ResolvedHTTPLinkOptions {
   return {
     url: opts.url.toString().replace(/\/$/, ''), // Remove any trailing slashes
     fetch: opts.fetch,
     AbortController: getAbortController(opts.AbortController),
+    transformer: getTransformer(opts.transformer),
+    methodOverride: opts.methodOverride,
   };
 }
 
@@ -68,14 +86,14 @@ export interface HTTPResult {
 }
 
 type GetInputOptions = {
-  runtime: TRPCClientRuntime;
+  transformer: CombinedDataTransformer;
 } & ({ input: unknown } | { inputs: unknown[] });
 
 function getInput(opts: GetInputOptions) {
   return 'input' in opts
-    ? opts.runtime.transformer.serialize(opts.input)
+    ? opts.transformer.input.serialize(opts.input)
     : arrayToDict(
-        opts.inputs.map((_input) => opts.runtime.transformer.serialize(_input)),
+        opts.inputs.map((_input) => opts.transformer.input.serialize(_input)),
       );
 }
 
@@ -85,11 +103,8 @@ export type HTTPBaseRequestOptions = GetInputOptions &
     path: string;
   };
 
-export type GetUrl = (opts: HTTPBaseRequestOptions) => string;
-export type GetBody = (
-  opts: HTTPBaseRequestOptions,
-) => RequestInitEsque['body'];
-
+type GetUrl = (opts: HTTPBaseRequestOptions) => string;
+type GetBody = (opts: HTTPBaseRequestOptions) => RequestInitEsque['body'];
 export type ContentOptions = {
   batchModeHeader?: 'stream';
   contentTypeHeader?: string;
@@ -105,7 +120,7 @@ export const getUrl: GetUrl = (opts) => {
   }
   if (opts.type === 'query') {
     const input = getInput(opts);
-    if (input !== undefined) {
+    if (input !== undefined && opts.methodOverride !== 'POST') {
       queryParts.push(`input=${encodeURIComponent(JSON.stringify(input))}`);
     }
   }
@@ -116,7 +131,7 @@ export const getUrl: GetUrl = (opts) => {
 };
 
 export const getBody: GetBody = (opts) => {
-  if (opts.type === 'query') {
+  if (opts.type === 'query' && opts.methodOverride !== 'POST') {
     return undefined;
   }
   const input = getInput(opts);
@@ -151,7 +166,13 @@ export async function fetchHTTPResponse(
   const url = opts.getUrl(opts);
   const body = opts.getBody(opts);
   const { type } = opts;
-  const resolvedHeaders = await opts.headers();
+  const resolvedHeaders = await (async () => {
+    const heads = await opts.headers();
+    if (Symbol.iterator in heads) {
+      return Object.fromEntries(heads);
+    }
+    return heads;
+  })();
   /* istanbul ignore if -- @preserve */
   if (type === 'subscription') {
     throw new Error('Subscriptions should use wsLink');
@@ -167,9 +188,9 @@ export async function fetchHTTPResponse(
   };
 
   return getFetch(opts.fetch)(url, {
-    method: METHOD[type],
+    method: opts.methodOverride ?? METHOD[type],
     signal: ac?.signal,
-    body: body,
+    body,
     headers,
   });
 }

package/src/links/internals/parseJSONStream.ts

@@ -1,15 +1,13 @@
 // Stream parsing adapted from https://www.loginradius.com/blog/engineering/guest-post/http-streaming-with-nodejs-and-fetch-api/
-import { TRPCResponse } from '@trpc/server/rpc';
-import { WebReadableStreamEsque } from '../../internals/types';
-import { HTTPHeaders } from '../types';
-import {
-  fetchHTTPResponse,
-  getBody,
-  getUrl,
-  HTTPBaseRequestOptions,
-  HTTPResult,
-} from './httpUtils';
-import { TextDecoderEsque } from './streamingUtils';
+import type { TRPCResponse } from '@trpc/server/unstable-core-do-not-import';
+import type {
+  NodeJSReadableStreamEsque,
+  WebReadableStreamEsque,
+} from '../../internals/types';
+import type { HTTPHeaders } from '../types';
+import type { HTTPBaseRequestOptions, HTTPResult } from './httpUtils';
+import { fetchHTTPResponse, getBody, getUrl } from './httpUtils';
+import type { TextDecoderEsque } from './streamingUtils';
 
 /**
  * @internal
@@ -26,7 +24,7 @@ export async function parseJSONStream<TReturn>(opts: {
   /**
    * As given by `(await fetch(url)).body`
    */
-  readableStream: NodeJS.ReadableStream | WebReadableStreamEsque;
+  readableStream: NodeJSReadableStreamEsque | WebReadableStreamEsque;
   /**
    * Called for each line of the stream
    */
@@ -69,7 +67,7 @@ export async function parseJSONStream<TReturn>(opts: {
  * @param onLine will be called for every line ('\n' delimited) in the stream
  */
 async function readLines(
-  readableStream: NodeJS.ReadableStream | WebReadableStreamEsque,
+  readableStream: NodeJSReadableStreamEsque | WebReadableStreamEsque,
   onLine: (line: string) => void,
   textDecoder: TextDecoderEsque,
 ) {
@@ -106,7 +104,7 @@ async function readLines(
  * Handle NodeJS stream
  */
 function readNodeChunks(
-  stream: NodeJS.ReadableStream,
+  stream: NodeJSReadableStreamEsque,
   onChunk: (chunk: Uint8Array) => void,
 ) {
   return new Promise<void>((resolve) => {

package/src/links/internals/retryLink.ts

@@ -1,8 +1,9 @@
 /* istanbul ignore file -- @preserve */
 // We're not actually exporting this link
-import { AnyRouter } from '@trpc/server';
-import { observable, Unsubscribable } from '@trpc/server/observable';
-import { TRPCLink } from '../types';
+import type { Unsubscribable } from '@trpc/server/observable';
+import { observable } from '@trpc/server/observable';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import type { TRPCLink } from '../types';
 
 /**
  * @internal used for testing

package/src/links/loggerLink.ts

@@ -5,10 +5,10 @@
 // Using triple-slash directive makes sure that it will be available,
 // even if end-user `tsconfig.json` omits it in the `lib` array.
 
-import { AnyRouter } from '@trpc/server';
 import { observable, tap } from '@trpc/server/observable';
-import { TRPCClientError } from '..';
-import { Operation, OperationResultEnvelope, TRPCLink } from './types';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import type { TRPCClientError } from '../TRPCClientError';
+import type { Operation, OperationResultEnvelope, TRPCLink } from './types';
 
 type ConsoleEsque = {
   log: (...args: any[]) => void;
@@ -135,7 +135,7 @@ function constructPartsAndArgs(
 
   const [light, dark] = palettes.css[type];
   const css = `
-    background-color: #${direction === 'up' ? light : dark}; 
+    background-color: #${direction === 'up' ? light : dark};
     color: ${direction === 'up' ? 'black' : 'white'};
     padding: 2px;
   `;
@@ -196,7 +196,7 @@ const defaultLogger =
   };
 
 /**
- * @see https://trpc.io/docs/client/links/loggerLink
+ * @link https://trpc.io/docs/v11/client/links/loggerLink
  */
 export function loggerLink<TRouter extends AnyRouter = AnyRouter>(
   opts: LoggerLinkOptions<TRouter> = {},

package/src/links/splitLink.ts

@@ -1,7 +1,7 @@
-import { AnyRouter } from '@trpc/server';
 import { observable } from '@trpc/server/observable';
+import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
 import { createChain } from './internals/createChain';
-import { Operation, TRPCLink } from './types';
+import type { Operation, TRPCLink } from './types';
 
 function asArray<TType>(value: TType | TType[]) {
   return Array.isArray(value) ? value : [value];

package/src/links/types.ts

@@ -1,12 +1,11 @@
-import {
-  AnyRouter,
-  CombinedDataTransformer,
-  DataTransformer,
-} from '@trpc/server';
-import { Observable, Observer } from '@trpc/server/observable';
-import { TRPCResultMessage, TRPCSuccessResponse } from '@trpc/server/rpc';
-import { ResponseEsque } from '../internals/types';
-import { TRPCClientError } from '../TRPCClientError';
+import type { Observable, Observer } from '@trpc/server/observable';
+import type {
+  InferrableClientTypes,
+  TRPCResultMessage,
+  TRPCSuccessResponse,
+} from '@trpc/server/unstable-core-do-not-import';
+import type { ResponseEsque } from '../internals/types';
+import type { TRPCClientError } from '../TRPCClientError';
 
 /**
  * @internal
@@ -37,10 +36,16 @@ export type Operation<TInput = unknown> = {
   context: OperationContext;
 };
 
+interface HeadersInitEsque {
+  [Symbol.iterator](): IterableIterator<[string, string]>;
+}
+
 /**
  * @internal
  */
-export type HTTPHeaders = Record<string, string[] | string | undefined>;
+export type HTTPHeaders =
+  | HeadersInitEsque
+  | Record<string, string[] | string | undefined>;
 
 /**
  * The default `fetch` implementation has an overloaded signature. By convention this library
@@ -52,9 +57,7 @@ export type TRPCFetch = (
 ) => Promise<ResponseEsque>;
 
 export interface TRPCClientRuntime {
-  transformer: DataTransformer;
-  // FIXME: we should be able to remove this - added as `withTRPC()` needs it, but we can have it as an extra option on SSR instead
-  combinedTransformer: CombinedDataTransformer;
+  // nothing here anymore
 }
 
 /**
@@ -71,33 +74,35 @@ export interface OperationResultEnvelope<TOutput> {
  * @internal
  */
 export type OperationResultObservable<
-  TRouter extends AnyRouter,
+  TInferrable extends InferrableClientTypes,
   TOutput,
-> = Observable<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
+> = Observable<OperationResultEnvelope<TOutput>, TRPCClientError<TInferrable>>;
 
 /**
  * @internal
  */
 export type OperationResultObserver<
-  TRouter extends AnyRouter,
+  TInferrable extends InferrableClientTypes,
   TOutput,
-> = Observer<OperationResultEnvelope<TOutput>, TRPCClientError<TRouter>>;
+> = Observer<OperationResultEnvelope<TOutput>, TRPCClientError<TInferrable>>;
 
 /**
  * @internal
  */
 export type OperationLink<
-  TRouter extends AnyRouter,
+  TInferrable extends InferrableClientTypes,
   TInput = unknown,
   TOutput = unknown,
 > = (opts: {
   op: Operation<TInput>;
-  next: (op: Operation<TInput>) => OperationResultObservable<TRouter, TOutput>;
-}) => OperationResultObservable<TRouter, TOutput>;
+  next: (
+    op: Operation<TInput>,
+  ) => OperationResultObservable<TInferrable, TOutput>;
+}) => OperationResultObservable<TInferrable, TOutput>;
 
 /**
  * @public
  */
-export type TRPCLink<TRouter extends AnyRouter> = (
+export type TRPCLink<TInferrable extends InferrableClientTypes> = (
   opts: TRPCClientRuntime,
-) => OperationLink<TRouter>;
+) => OperationLink<TInferrable>;