@trpc/react-query 11.0.0-rc.577 → 11.0.0-rc.584

package/src/rsc.tsx

@@ -73,7 +73,7 @@ type Caller<TRouter extends AnyRouter> = ReturnType<
 // ts-prune-ignore-next
 /**
  * @note This requires `@tanstack/react-query@^5.49.0`
- * @note Make sure to have `dehyrate.serializeData` and `hydrate.deserializeData`
+ * @note Make sure to have `dehydrate.serializeData` and `hydrate.deserializeData`
  * set to your data transformer in your `QueryClient` factory.
  * @example
  * ```ts

package/src/server/ssgProxy.ts

@@ -1,11 +1,10 @@
 import type {
   DehydratedState,
   DehydrateOptions,
-  InfiniteData,
   QueryClient,
 } from '@tanstack/react-query';
 import { dehydrate } from '@tanstack/react-query';
-import type { inferRouterClient, TRPCClientError } from '@trpc/client';
+import type { inferRouterClient } from '@trpc/client';
 import { getUntypedClient, TRPCUntypedClient } from '@trpc/client';
 import type { CoercedTransformerParameters } from '@trpc/client/unstable-internals';
 import {
@@ -13,14 +12,11 @@ import {
   type TransformerOptions,
 } from '@trpc/client/unstable-internals';
 import type {
-  AnyProcedure,
   AnyQueryProcedure,
   AnyRootTypes,
   AnyRouter,
   inferClientTypes,
-  inferProcedureInput,
   inferRouterContext,
-  inferTransformedProcedureOutput,
   Maybe,
   ProtectedIntersection,
   RouterRecord,
@@ -33,7 +29,7 @@ import {
 import { getQueryKeyInternal } from '../internals/getQueryKey';
 import type {
   CreateTRPCReactQueryClientConfig,
-  ExtractCursorType,
+  DecorateQueryProcedure,
   TRPCFetchInfiniteQueryOptions,
   TRPCFetchQueryOptions,
 } from '../shared';
@@ -52,61 +48,13 @@ type CreateServerSideHelpersOptions<TRouter extends AnyRouter> =
   CreateTRPCReactQueryClientConfig &
     (CreateSSGHelpersExternal<TRouter> | CreateSSGHelpersInternal<TRouter>);
 
-type DecorateProcedure<
-  TRoot extends AnyRootTypes,
-  TProcedure extends AnyProcedure,
-> = {
-  /**
-   * @see https://tanstack.com/query/v5/docs/framework/react/guides/prefetching
-   */
-  fetch(
-    input: inferProcedureInput<TProcedure>,
-    opts?: TRPCFetchQueryOptions<
-      inferTransformedProcedureOutput<TRoot, TProcedure>,
-      TRPCClientError<TRoot>
-    >,
-  ): Promise<inferTransformedProcedureOutput<TRoot, TProcedure>>;
-
-  /**
-   * @see https://tanstack.com/query/v5/docs/framework/react/guides/prefetching
-   */
-  fetchInfinite(
-    input: inferProcedureInput<TProcedure>,
-    opts?: TRPCFetchInfiniteQueryOptions<
-      inferProcedureInput<TProcedure>,
-      inferTransformedProcedureOutput<TRoot, TProcedure>,
-      TRPCClientError<TRoot>
-    >,
-  ): Promise<
-    InfiniteData<
-      inferTransformedProcedureOutput<TRoot, TProcedure>,
-      NonNullable<ExtractCursorType<inferProcedureInput<TProcedure>>> | null
-    >
-  >;
-
-  /**
-   * @see https://tanstack.com/query/v5/docs/framework/react/guides/prefetching
-   */
-  prefetch(
-    input: inferProcedureInput<TProcedure>,
-    opts?: TRPCFetchQueryOptions<
-      inferTransformedProcedureOutput<TRoot, TProcedure>,
-      TRPCClientError<TRoot>
-    >,
-  ): Promise<void>;
-
-  /**
-   * @see https://tanstack.com/query/v5/docs/framework/react/guides/prefetching
-   */
-  prefetchInfinite(
-    input: inferProcedureInput<TProcedure>,
-    opts?: TRPCFetchInfiniteQueryOptions<
-      inferProcedureInput<TProcedure>,
-      inferTransformedProcedureOutput<TRoot, TProcedure>,
-      TRPCClientError<TRoot>
-    >,
-  ): Promise<void>;
-};
+type SSGFns =
+  | 'queryOptions'
+  | 'infiniteQueryOptions'
+  | 'fetch'
+  | 'fetchInfinite'
+  | 'prefetch'
+  | 'prefetchInfinite';
 
 /**
  * @internal
@@ -120,12 +68,12 @@ type DecoratedProcedureSSGRecord<
       ? DecoratedProcedureSSGRecord<TRoot, $Value>
       : // utils only apply to queries
       $Value extends AnyQueryProcedure
-      ? DecorateProcedure<TRoot, $Value>
+      ? Pick<DecorateQueryProcedure<TRoot, $Value>, SSGFns>
       : never
     : never;
 };
 
-type AnyDecoratedProcedure = DecorateProcedure<any, any>;
+type AnyDecoratedProcedure = Pick<DecorateQueryProcedure<any, any>, SSGFns>;
 
 /**
  * Create functions you can use for server-side rendering / static generation
@@ -210,6 +158,14 @@ export function createServerSideHelpers<TRouter extends AnyRouter>(
     );
 
     const helperMap: Record<keyof AnyDecoratedProcedure, () => unknown> = {
+      queryOptions: () => {
+        const args1 = args[1] as Maybe<any>;
+        return { ...args1, queryKey, queryFn };
+      },
+      infiniteQueryOptions: () => {
+        const args1 = args[1] as Maybe<any>;
+        return { ...args1, queryKey, queryFn };
+      },
       fetch: () => {
         const args1 = args[1] as Maybe<TRPCFetchQueryOptions<any, any>>;
         return queryClient.fetchQuery({ ...args1, queryKey, queryFn });

package/src/shared/hooks/createHooksInternal.tsx

@@ -24,7 +24,10 @@ import {
   getMutationKeyInternal,
   getQueryKeyInternal,
 } from '../../internals/getQueryKey';
-import { useHookResult } from '../../internals/useHookResult';
+import {
+  buildQueryFromAsyncIterable,
+  useHookResult,
+} from '../../internals/trpcResult';
 import type {
   TRPCUseQueries,
   TRPCUseSuspenseQueries,
@@ -193,26 +196,11 @@ export function createRootHooks<
               );
 
               if (isAsyncIterable(result)) {
-                const queryCache = queryClient.getQueryCache();
-
-                const query = queryCache.build(queryClient, {
+                return buildQueryFromAsyncIterable(
+                  result,
+                  queryClient,
                   queryKey,
-                });
-
-                query.setState({
-                  data: [],
-                  status: 'success',
-                });
-
-                const aggregate: unknown[] = [];
-                for await (const value of result) {
-                  aggregate.push(value);
-
-                  query.setState({
-                    data: [...aggregate],
-                  });
-                }
-                return aggregate;
+                );
               }
               return result;
             },

package/src/shared/hooks/types.ts

@@ -185,7 +185,7 @@ export type CreateClient<TRouter extends AnyRouter> = (
   opts: CreateTRPCClientOptions<TRouter>,
 ) => TRPCUntypedClient<TRouter>;
 
-type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<
+export type coerceAsyncIterableToArray<TValue> = TValue extends AsyncIterable<
   infer $Inferred
 >
   ? $Inferred[]

package/src/shared/proxy/utilsProxy.ts

@@ -10,6 +10,7 @@ import type {
   RefetchQueryFilters,
   ResetOptions,
   SetDataOptions,
+  SkipToken,
   Updater,
 } from '@tanstack/react-query';
 import type { TRPCClientError } from '@trpc/client';
@@ -44,11 +45,113 @@ import {
 } from '../../internals/getQueryKey';
 import type { InferMutationOptions } from '../../utils/inferReactQueryProcedure';
 import type { ExtractCursorType } from '../hooks/types';
-
-type DecorateQueryProcedure<
+import type {
+  DefinedTRPCInfiniteQueryOptionsIn,
+  DefinedTRPCInfiniteQueryOptionsOut,
+  DefinedTRPCQueryOptionsIn,
+  DefinedTRPCQueryOptionsOut,
+  UndefinedTRPCInfiniteQueryOptionsIn,
+  UndefinedTRPCInfiniteQueryOptionsOut,
+  UndefinedTRPCQueryOptionsIn,
+  UndefinedTRPCQueryOptionsOut,
+  UnusedSkipTokenTRPCInfiniteQueryOptionsIn,
+  UnusedSkipTokenTRPCInfiniteQueryOptionsOut,
+} from '../types';
+
+export type DecorateQueryProcedure<
   TRoot extends AnyRootTypes,
   TProcedure extends AnyQueryProcedure,
 > = {
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/queryOptions#queryoptions
+   */
+  queryOptions<
+    TQueryFnData extends inferTransformedProcedureOutput<TRoot, TProcedure>,
+    TData = TQueryFnData,
+  >(
+    input: inferProcedureInput<TProcedure> | SkipToken,
+    opts: DefinedTRPCQueryOptionsIn<
+      TQueryFnData,
+      TData,
+      TRPCClientError<TRoot>
+    >,
+  ): DefinedTRPCQueryOptionsOut<TQueryFnData, TData, TRPCClientError<TRoot>>;
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/queryOptions#queryoptions
+   */
+  queryOptions<
+    TQueryFnData extends inferTransformedProcedureOutput<TRoot, TProcedure>,
+    TData = TQueryFnData,
+  >(
+    input: inferProcedureInput<TProcedure> | SkipToken,
+    opts?: UndefinedTRPCQueryOptionsIn<
+      TQueryFnData,
+      TData,
+      TRPCClientError<TRoot>
+    >,
+  ): UndefinedTRPCQueryOptionsOut<TQueryFnData, TData, TRPCClientError<TRoot>>;
+
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/infiniteQueryOptions#infinitequeryoptions
+   */
+  infiniteQueryOptions<
+    TQueryFnData extends inferTransformedProcedureOutput<TRoot, TProcedure>,
+    TData = TQueryFnData,
+  >(
+    input: inferProcedureInput<TProcedure> | SkipToken,
+    opts: DefinedTRPCInfiniteQueryOptionsIn<
+      inferProcedureInput<TProcedure>,
+      TQueryFnData,
+      TData,
+      TRPCClientError<TRoot>
+    >,
+  ): DefinedTRPCInfiniteQueryOptionsOut<
+    inferProcedureInput<TProcedure>,
+    TQueryFnData,
+    TData,
+    TRPCClientError<TRoot>
+  >;
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/infiniteQueryOptions#infinitequeryoptions
+   */
+  infiniteQueryOptions<
+    TQueryFnData extends inferTransformedProcedureOutput<TRoot, TProcedure>,
+    TData = TQueryFnData,
+  >(
+    input: inferProcedureInput<TProcedure>,
+    opts: UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
+      inferProcedureInput<TProcedure>,
+      TQueryFnData,
+      TData,
+      TRPCClientError<TRoot>
+    >,
+  ): UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+    inferProcedureInput<TProcedure>,
+    TQueryFnData,
+    TData,
+    TRPCClientError<TRoot>
+  >;
+  /**
+   * @see https://tanstack.com/query/latest/docs/framework/react/reference/infiniteQueryOptions#infinitequeryoptions
+   */
+  infiniteQueryOptions<
+    TQueryFnData extends inferTransformedProcedureOutput<TRoot, TProcedure>,
+    TData = TQueryFnData,
+  >(
+    input: inferProcedureInput<TProcedure> | SkipToken,
+    opts?: UndefinedTRPCInfiniteQueryOptionsIn<
+      inferProcedureInput<TProcedure>,
+      TQueryFnData,
+      TData,
+      TRPCClientError<TRoot>
+    >,
+  ): UndefinedTRPCInfiniteQueryOptionsOut<
+    inferProcedureInput<TProcedure>,
+    TQueryFnData,
+    TData,
+    TRPCClientError<TRoot>
+  >;
+
   /**
    * @see https://tanstack.com/query/v5/docs/reference/QueryClient#queryclientfetchquery
    */
@@ -308,6 +411,7 @@ export const getQueryType = (
   utilName: keyof AnyDecoratedProcedure,
 ): QueryType => {
   switch (utilName) {
+    case 'queryOptions':
     case 'fetch':
     case 'ensureData':
     case 'prefetch':
@@ -316,6 +420,7 @@ export const getQueryType = (
     case 'setQueriesData':
       return 'query';
 
+    case 'infiniteQueryOptions':
     case 'fetchInfinite':
     case 'prefetchInfinite':
     case 'getInfiniteData':
@@ -350,6 +455,9 @@ function createRecursiveUtilsProxy<TRouter extends AnyRouter>(
     const queryKey = getQueryKeyInternal(path, input, queryType);
 
     const contextMap: Record<keyof AnyDecoratedProcedure, () => unknown> = {
+      infiniteQueryOptions: () =>
+        context.infiniteQueryOptions(path, queryKey, args[0]),
+      queryOptions: () => context.queryOptions(path, queryKey, ...args),
       /**
        * DecorateQueryProcedure
        */

package/src/shared/types.ts

@@ -1,8 +1,209 @@
-import type { QueryClient } from '@tanstack/react-query';
+import type {
+  DataTag,
+  DefinedInitialDataInfiniteOptions,
+  DefinedInitialDataOptions,
+  InfiniteData,
+  QueryClient,
+  UndefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataOptions,
+  UnusedSkipTokenInfiniteOptions,
+} from '@tanstack/react-query';
 import type {
   AnyRouter,
+  DistributiveOmit,
   MaybePromise,
 } from '@trpc/server/unstable-core-do-not-import';
+import type { TRPCQueryKey } from '../internals/getQueryKey';
+import type {
+  coerceAsyncIterableToArray,
+  ExtractCursorType,
+  TRPCReactRequestOptions,
+} from './hooks/types';
+
+export interface TRPCQueryBaseOptions {
+  /**
+   * tRPC-related options
+   */
+  trpc?: TRPCReactRequestOptions;
+}
+
+export interface TRPCQueryOptionsResult {
+  trpc: {
+    path: string;
+  };
+}
+
+type TRPCOptionOverrides = 'queryKey' | 'queryFn' | 'queryHashFn' | 'queryHash';
+type TRPCInfiniteOptionOverrides = TRPCOptionOverrides | 'initialPageParam';
+
+/**
+ * QueryOptions API helpers
+ */
+export interface UndefinedTRPCQueryOptionsIn<TQueryFnData, TData, TError>
+  extends DistributiveOmit<
+      UndefinedInitialDataOptions<
+        coerceAsyncIterableToArray<TQueryFnData>,
+        TError,
+        coerceAsyncIterableToArray<TData>,
+        TRPCQueryKey
+      >,
+      TRPCOptionOverrides
+    >,
+    TRPCQueryBaseOptions {}
+
+export interface UndefinedTRPCQueryOptionsOut<TQueryFnData, TOutput, TError>
+  extends UndefinedInitialDataOptions<
+      coerceAsyncIterableToArray<TQueryFnData>,
+      TError,
+      coerceAsyncIterableToArray<TOutput>,
+      TRPCQueryKey
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, coerceAsyncIterableToArray<TOutput>>;
+}
+
+export interface DefinedTRPCQueryOptionsIn<TQueryFnData, TData, TError>
+  extends DistributiveOmit<
+      DefinedInitialDataOptions<
+        coerceAsyncIterableToArray<TQueryFnData>,
+        TError,
+        coerceAsyncIterableToArray<TData>,
+        TRPCQueryKey
+      >,
+      TRPCOptionOverrides
+    >,
+    TRPCQueryBaseOptions {}
+
+export interface DefinedTRPCQueryOptionsOut<TQueryFnData, TData, TError>
+  extends DefinedInitialDataOptions<
+      coerceAsyncIterableToArray<TQueryFnData>,
+      TError,
+      coerceAsyncIterableToArray<TData>,
+      TRPCQueryKey
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, coerceAsyncIterableToArray<TData>>;
+}
+
+/**
+ * InifiniteQueryOptions helpers
+ */
+export interface UndefinedTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UndefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      TRPCInfiniteOptionOverrides
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface UndefinedTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UndefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface DefinedTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      DefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      TRPCInfiniteOptionOverrides
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface DefinedTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      DefinedInitialDataInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface UnusedSkipTokenTRPCInfiniteQueryOptionsIn<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UnusedSkipTokenInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      TRPCInfiniteOptionOverrides
+    >,
+    TRPCQueryBaseOptions {
+  initialCursor?: NonNullable<ExtractCursorType<TInput>> | null;
+}
+
+export interface UnusedSkipTokenTRPCInfiniteQueryOptionsOut<
+  TInput,
+  TQueryFnData,
+  TData,
+  TError,
+> extends DistributiveOmit<
+      UnusedSkipTokenInfiniteOptions<
+        TQueryFnData,
+        TError,
+        InfiniteData<TData, NonNullable<ExtractCursorType<TInput>> | null>,
+        TRPCQueryKey,
+        NonNullable<ExtractCursorType<TInput>> | null
+      >,
+      'initialPageParam'
+    >,
+    TRPCQueryOptionsResult {
+  queryKey: DataTag<TRPCQueryKey, TData>;
+  initialPageParam: NonNullable<ExtractCursorType<TInput>> | null;
+}
 
 /**
  * @internal

package/src/utils/createUtilityFunctions.ts

@@ -1,9 +1,21 @@
-import type { QueryClient } from '@tanstack/react-query';
+import type { QueryFunctionContext } from '@tanstack/react-query';
+import {
+  infiniteQueryOptions,
+  queryOptions,
+  skipToken,
+  type QueryClient,
+} from '@tanstack/react-query';
 import type { CreateTRPCClient } from '@trpc/client';
 import { getUntypedClient, TRPCUntypedClient } from '@trpc/client';
 import type { AnyRouter } from '@trpc/server/unstable-core-do-not-import';
+import { isAsyncIterable } from '@trpc/server/unstable-core-do-not-import';
 import { getClientArgs } from '../internals/getClientArgs';
-import type { TRPCQueryUtils } from '../shared';
+import type { TRPCQueryKey } from '../internals/getQueryKey';
+import {
+  buildQueryFromAsyncIterable,
+  createTRPCOptionsResult,
+} from '../internals/trpcResult';
+import { type TRPCQueryUtils } from '../shared';
 
 export interface CreateQueryUtilsOptions<TRouter extends AnyRouter> {
   /**
@@ -30,6 +42,82 @@ export function createUtilityFunctions<TRouter extends AnyRouter>(
     client instanceof TRPCUntypedClient ? client : getUntypedClient(client);
 
   return {
+    infiniteQueryOptions: (path, queryKey, opts) => {
+      const inputIsSkipToken = queryKey[1]?.input === skipToken;
+
+      const queryFn = async (
+        queryFnContext: QueryFunctionContext<TRPCQueryKey, unknown>,
+      ): Promise<unknown> => {
+        const actualOpts = {
+          ...opts,
+          trpc: {
+            ...opts?.trpc,
+            ...(opts?.trpc?.abortOnUnmount
+              ? { signal: queryFnContext.signal }
+              : { signal: null }),
+          },
+        };
+
+        const result = await untypedClient.query(
+          ...getClientArgs(queryKey, actualOpts, {
+            direction: queryFnContext.direction,
+            pageParam: queryFnContext.pageParam,
+          }),
+        );
+
+        return result;
+      };
+
+      return Object.assign(
+        infiniteQueryOptions({
+          ...opts,
+          initialData: opts?.initialData as any,
+          queryKey,
+          queryFn: inputIsSkipToken ? skipToken : queryFn,
+          initialPageParam: (opts?.initialCursor as any) ?? null,
+        }),
+        { trpc: createTRPCOptionsResult({ path }) },
+      );
+    },
+
+    queryOptions: (path, queryKey, opts) => {
+      const inputIsSkipToken = queryKey[1]?.input === skipToken;
+
+      const queryFn = async (
+        queryFnContext: QueryFunctionContext<TRPCQueryKey>,
+      ): Promise<unknown> => {
+        const actualOpts = {
+          ...opts,
+          trpc: {
+            ...opts?.trpc,
+            ...(opts?.trpc?.abortOnUnmount
+              ? { signal: queryFnContext.signal }
+              : { signal: null }),
+          },
+        };
+
+        const result = await untypedClient.query(
+          ...getClientArgs(queryKey, actualOpts),
+        );
+
+        if (isAsyncIterable(result)) {
+          return buildQueryFromAsyncIterable(result, queryClient, queryKey);
+        }
+
+        return result;
+      };
+
+      return Object.assign(
+        queryOptions({
+          ...opts,
+          initialData: opts?.initialData as any,
+          queryKey,
+          queryFn: inputIsSkipToken ? skipToken : queryFn,
+        }),
+        { trpc: createTRPCOptionsResult({ path }) },
+      );
+    },
+
     fetchQuery: (queryKey, opts) => {
       return queryClient.fetchQuery({
         ...opts,

package/dist/internals/useHookResult.d.ts

@@ -1,8 +0,0 @@
-import type { TRPCHookResult } from '../shared/hooks/types';
-/**
- * Makes a stable reference of the `trpc` prop
- */
-export declare function useHookResult(value: {
-    path: readonly string[];
-}): TRPCHookResult['trpc'];
-//# sourceMappingURL=useHookResult.d.ts.map

package/dist/internals/useHookResult.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useHookResult.d.ts","sourceRoot":"","sources":["../../src/internals/useHookResult.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE;IACnC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;CACzB,GAAG,cAAc,CAAC,MAAM,CAAC,CAQzB"}