@apollo/client 4.2.0-alpha.2 → 4.2.0-alpha.4

package/react/hooks-compiled/useBackgroundQuery.d.ts

@@ -1,4 +1,4 @@
-import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, OperationVariables, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
+import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, OperationVariables, RefetchOn, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import type { QueryRef } from "@apollo/client/react";
 import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
@@ -72,6 +72,25 @@ export declare namespace useBackgroundQuery {
             */
             queryKey?: string | number | any[];
             /**
+            * Determines whether events trigger refetches for the query. Provide an
+            * object mapping each refetch event to `true` (enable), `false` (disable)
+            * or a callback function that returns `true`/`false` to control individual
+            * events. Provide `false` to disable all automatic refetch events for this
+            * query. Provide `true` to enable all automatic refetch events for this query.
+            * Provide a callback function to perform additional logic to determine
+            * whether to enable or disable a refetch for a query.
+            * 
+            * `@remarks`
+            * `refetchOn` inherits from `defaultOptions.watchQuery.refetchOn`. If
+            * `defaultOptions.watchQuery.refetchOn` is not set, all refetch events are
+            * enabled by default.
+            * 
+            * This option only has an effect when the client is configured with a
+            * `refetchEventManager`.
+            * @docGroup 1. Operation options
+            */
+            refetchOn?: RefetchOn.Option;
+            /**
             * If `true`, the query is not executed. The default value is `false`.
             * 
             * @deprecated We recommend using `skipToken` in place of the `skip` option as
@@ -152,78 +171,139 @@ export declare namespace useBackgroundQuery {
         result: useBackgroundQuery.Result<TData, TVariables>
     ];
     namespace DocumentationTypes {
-        /**
-         * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-         *
-         * @returns A tuple containing:
-         *
-         * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
-         * 2.  An object containing helper functions for the query:
-         *     - `refetch`: A function to re-execute the query
-         *     - `fetchMore`: A function to fetch more results for pagination
-         *     - `subscribeToMore`: A function to subscribe to updates
-         *
-         * @example
-         *
-         * ```jsx
-         * import { Suspense } from "react";
-         * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
-         * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
-         *
-         * const query = gql`
-         *   foo {
-         *     bar
-         *   }
-         * `;
-         *
-         * const client = new ApolloClient({
-         *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
-         *   cache: new InMemoryCache(),
-         * });
-         *
-         * function SuspenseFallback() {
-         *   return <div>Loading...</div>;
-         * }
-         *
-         * function Child({ queryRef }) {
-         *   const { data } = useReadQuery(queryRef);
-         *
-         *   return <div>{data.foo.bar}</div>;
-         * }
-         *
-         * function Parent() {
-         *   const [queryRef] = useBackgroundQuery(query);
-         *
-         *   return (
-         *     <Suspense fallback={<SuspenseFallback />}>
-         *       <Child queryRef={queryRef} />
-         *     </Suspense>
-         *   );
-         * }
-         *
-         * function App() {
-         *   return (
-         *     <ApolloProvider client={client}>
-         *       <Parent />
-         *     </ApolloProvider>
-         *   );
-         * }
-         * ```
-         *
-         * @param query - A GraphQL query document parsed into an AST by `gql`.
-         * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
-         */
         interface useBackgroundQuery {
+            /**
+             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+             *
+             * @returns A tuple containing:
+             *
+             * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+             * 2.  An object containing helper functions for the query:
+             *     - `refetch`: A function to re-execute the query
+             *     - `fetchMore`: A function to fetch more results for pagination
+             *     - `subscribeToMore`: A function to subscribe to updates
+             *
+             * @example
+             *
+             * ```jsx
+             * import { Suspense } from "react";
+             * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+             * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+             *
+             * const query = gql`
+             *   foo {
+             *     bar
+             *   }
+             * `;
+             *
+             * const client = new ApolloClient({
+             *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+             *   cache: new InMemoryCache(),
+             * });
+             *
+             * function SuspenseFallback() {
+             *   return <div>Loading...</div>;
+             * }
+             *
+             * function Child({ queryRef }) {
+             *   const { data } = useReadQuery(queryRef);
+             *
+             *   return <div>{data.foo.bar}</div>;
+             * }
+             *
+             * function Parent() {
+             *   const [queryRef] = useBackgroundQuery(query);
+             *
+             *   return (
+             *     <Suspense fallback={<SuspenseFallback />}>
+             *       <Child queryRef={queryRef} />
+             *     </Suspense>
+             *   );
+             * }
+             *
+             * function App() {
+             *   return (
+             *     <ApolloProvider client={client}>
+             *       <Parent />
+             *     </ApolloProvider>
+             *   );
+             * }
+             * ```
+             *
+             * @param query - A GraphQL query document parsed into an AST by `gql`.
+             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
+             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<TVariables>): [
                 QueryRef<TData, TVariables> | undefined,
                 useBackgroundQuery.Result<TData, TVariables>
             ];
         }
-        /**
-        * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
-        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
-        */
         interface useBackgroundQuery_Deprecated {
+            /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            *
+            *
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
+            */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<TVariables>): [
                 QueryRef<TData, TVariables> | undefined,
                 useBackgroundQuery.Result<TData, TVariables>
@@ -232,11 +312,135 @@ export declare namespace useBackgroundQuery {
     }
     namespace Signatures {
         /**
+        * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        * 
+        * 
+        * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+        * 
+        * @returns A tuple containing:
+        * 
+        * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+        * 2.  An object containing helper functions for the query:
+        *     - `refetch`: A function to re-execute the query
+        *     - `fetchMore`: A function to fetch more results for pagination
+        *     - `subscribeToMore`: A function to subscribe to updates
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { Suspense } from "react";
+        * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+        * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+        * 
+        * const query = gql`
+        *   foo {
+        *     bar
+        *   }
+        * `;
+        * 
+        * const client = new ApolloClient({
+        *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+        *   cache: new InMemoryCache(),
+        * });
+        * 
+        * function SuspenseFallback() {
+        *   return <div>Loading...</div>;
+        * }
+        * 
+        * function Child({ queryRef }) {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   return <div>{data.foo.bar}</div>;
+        * }
+        * 
+        * function Parent() {
+        *   const [queryRef] = useBackgroundQuery(query);
+        * 
+        *   return (
+        *     <Suspense fallback={<SuspenseFallback />}>
+        *       <Child queryRef={queryRef} />
+        *     </Suspense>
+        *   );
+        * }
         * 
+        * function App() {
+        *   return (
+        *     <ApolloProvider client={client}>
+        *       <Parent />
+        *     </ApolloProvider>
+        *   );
+        * }
+        * ```
+        * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
         */
         interface Classic {
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
             * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 /** @deprecated `returnPartialData` has no effect on `no-cache` queries */
@@ -247,7 +451,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
             * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
@@ -257,7 +523,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
             * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
@@ -267,7 +595,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
             * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 errorPolicy: "ignore" | "all";
@@ -276,7 +666,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
             * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
@@ -286,7 +738,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
             * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
@@ -296,7 +810,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
             * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
@@ -305,7 +881,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
             * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
@@ -314,7 +952,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
             * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
@@ -323,11 +1023,135 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
             * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): [undefined, useBackgroundQuery.Result<TData, TVariables>];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
             * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
@@ -336,7 +1160,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
             * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
@@ -345,7 +1231,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
             * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                 options?: useBackgroundQuery.Options<NoInfer<TVariables>>
@@ -354,7 +1302,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
             * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                 options?: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>
@@ -363,7 +1373,69 @@ export declare namespace useBackgroundQuery {
                 useBackgroundQuery.Result<TData, TVariables>
             ];
             /**
+            * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
             * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
@@ -371,25 +1443,315 @@ export declare namespace useBackgroundQuery {
             ];
         }
         /**
+        * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+        * 
+        * @returns A tuple containing:
+        * 
+        * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+        * 2.  An object containing helper functions for the query:
+        *     - `refetch`: A function to re-execute the query
+        *     - `fetchMore`: A function to fetch more results for pagination
+        *     - `subscribeToMore`: A function to subscribe to updates
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { Suspense } from "react";
+        * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+        * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+        * 
+        * const query = gql`
+        *   foo {
+        *     bar
+        *   }
+        * `;
+        * 
+        * const client = new ApolloClient({
+        *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+        *   cache: new InMemoryCache(),
+        * });
+        * 
+        * function SuspenseFallback() {
+        *   return <div>Loading...</div>;
+        * }
+        * 
+        * function Child({ queryRef }) {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   return <div>{data.foo.bar}</div>;
+        * }
+        * 
+        * function Parent() {
+        *   const [queryRef] = useBackgroundQuery(query);
+        * 
+        *   return (
+        *     <Suspense fallback={<SuspenseFallback />}>
+        *       <Child queryRef={queryRef} />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function App() {
+        *   return (
+        *     <ApolloProvider client={client}>
+        *       <Parent />
+        *     </ApolloProvider>
+        *   );
+        * }
+        * ```
         * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
         */
         interface Modern {
             /**
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
             * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData, TVariables extends OperationVariables, TOptions extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): useBackgroundQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
             /**
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
             * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData, TVariables extends OperationVariables, TOptions extends never>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, skipToken: SkipToken): useBackgroundQuery.ResultForOptions<TData, TVariables, SkipToken>;
             /**
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+            * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
             * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData, TVariables extends OperationVariables, TOptions extends useBackgroundQuery.Options<NoInfer<TVariables>> & VariablesOption<TVariables & {
                 [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
             }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions] : [options: TOptions]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions>;
             /**
+            * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @returns A tuple containing:
+            * 
+            * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+            * 2.  An object containing helper functions for the query:
+            *     - `refetch`: A function to re-execute the query
+            *     - `fetchMore`: A function to fetch more results for pagination
+            *     - `subscribeToMore`: A function to subscribe to updates
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+            * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
             * 
+            * const query = gql`
+            *   foo {
+            *     bar
+            *   }
+            * `;
+            * 
+            * const client = new ApolloClient({
+            *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+            *   cache: new InMemoryCache(),
+            * });
+            * 
+            * function SuspenseFallback() {
+            *   return <div>Loading...</div>;
+            * }
+            * 
+            * function Child({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.foo.bar}</div>;
+            * }
+            * 
+            * function Parent() {
+            *   const [queryRef] = useBackgroundQuery(query);
+            * 
+            *   return (
+            *     <Suspense fallback={<SuspenseFallback />}>
+            *       <Child queryRef={queryRef} />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function App() {
+            *   return (
+            *     <ApolloProvider client={client}>
+            *       <Parent />
+            *     </ApolloProvider>
+            *   );
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
             <TData, TVariables extends OperationVariables, TOptions extends useBackgroundQuery.Options<NoInfer<TVariables>> & VariablesOption<TVariables & {
                 [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
@@ -398,7 +1760,65 @@ export declare namespace useBackgroundQuery {
         type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
     }
     /**
+    * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+    * 
+    * @returns A tuple containing:
+    * 
+    * 1.  A `QueryRef` that can be passed to `useReadQuery` to read the query result. The `queryRef` is `undefined` if the query is skipped.
+    * 2.  An object containing helper functions for the query:
+    *     - `refetch`: A function to re-execute the query
+    *     - `fetchMore`: A function to fetch more results for pagination
+    *     - `subscribeToMore`: A function to subscribe to updates
+    * 
+    * @example
+    * 
+    * ```jsx
+    * import { Suspense } from "react";
+    * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+    * import { useBackgroundQuery, useReadQuery } from "@apollo/client/react";
+    * 
+    * const query = gql`
+    *   foo {
+    *     bar
+    *   }
+    * `;
+    * 
+    * const client = new ApolloClient({
+    *   link: new HttpLink({ uri: "http://localhost:4000/graphql" }),
+    *   cache: new InMemoryCache(),
+    * });
+    * 
+    * function SuspenseFallback() {
+    *   return <div>Loading...</div>;
+    * }
+    * 
+    * function Child({ queryRef }) {
+    *   const { data } = useReadQuery(queryRef);
+    * 
+    *   return <div>{data.foo.bar}</div>;
+    * }
+    * 
+    * function Parent() {
+    *   const [queryRef] = useBackgroundQuery(query);
+    * 
+    *   return (
+    *     <Suspense fallback={<SuspenseFallback />}>
+    *       <Child queryRef={queryRef} />
+    *     </Suspense>
+    *   );
+    * }
+    * 
+    * function App() {
+    *   return (
+    *     <ApolloProvider client={client}>
+    *       <Parent />
+    *     </ApolloProvider>
+    *   );
+    * }
+    * ```
     * 
+    * @param query - A GraphQL query document parsed into an AST by `gql`.
+    * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
     */
     interface Signature extends Signatures.Evaluated {
     }