@apollo/client 4.2.0-alpha.1 → 4.2.0-alpha.3

package/react/hooks/useBackgroundQuery.d.ts

@@ -2,7 +2,7 @@ import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, Operation
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import type { QueryRef } from "@apollo/client/react";
 import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
-import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, VariablesOption } from "@apollo/client/utilities/internal";
+import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 import type { SkipToken } from "./constants.js";
 export declare namespace useBackgroundQuery {
     import _self = useBackgroundQuery;
@@ -144,8 +144,159 @@ export declare namespace useBackgroundQuery {
             }
         }
     }
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+        skip: false;
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options<TVariables> | SkipToken> = [
+        queryRef: TOptions extends any ? TOptions extends SkipToken ? undefined : QueryRef<TData, TVariables, "complete" | "streaming" | ((OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> extends "none" ? never : "empty") | (OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial"))> | (OptionWithFallback<TOptions, DefaultOptions, "skip"> extends false ? never : undefined) : never,
+        result: useBackgroundQuery.Result<TData, TVariables>
+    ];
     namespace DocumentationTypes {
+        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>
+            ];
+        }
+        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>
+            ];
+        }
+    }
+    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:
@@ -206,770 +357,1452 @@ export declare namespace useBackgroundQuery {
         * @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.
         */
-        function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<TVariables>): [
-            QueryRef<TData, TVariables> | undefined,
-            useBackgroundQuery.Result<TData, TVariables>
-        ];
+        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 */
+                returnPartialData: boolean;
+                fetchPolicy: "no-cache";
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming">,
+                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;
+                errorPolicy: "ignore" | "all";
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
+                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;
+                errorPolicy: "ignore" | "all";
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">,
+                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";
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
+                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;
+                returnPartialData: false;
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming"> | 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: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                skip: boolean;
+                returnPartialData: boolean;
+            }): [
+                (QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | 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: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                returnPartialData: false;
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming">,
+                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;
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming" | "partial">,
+                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;
+            }): [
+                QueryRef<TData, TVariables, "complete" | "streaming"> | 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): [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;
+            })): [
+                QueryRef<TData, TVariables, "complete" | "streaming"> | 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: boolean;
+            })): [
+                (QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | 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]: {} extends TVariables ? [
+                options?: useBackgroundQuery.Options<NoInfer<TVariables>>
+            ] : [options: useBackgroundQuery.Options<NoInfer<TVariables>>]): [
+                QueryRef<TData, TVariables, "complete" | "streaming">,
+                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>>
+            ] : [options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>]): [
+                QueryRef<TData, TVariables, "complete" | "streaming"> | 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>>): [
+                QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
+                useBackgroundQuery.Result<TData, TVariables>
+            ];
+        }
+        /**
+        * 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;
+            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions | SkipToken] : [options: TOptions | SkipToken]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions | SkipToken>;
+        }
+        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 {
     }
 }
-/**
- * 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.
- */
-export declare function useBackgroundQuery<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 */
-    returnPartialData: boolean;
-    fetchPolicy: "no-cache";
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: false;
-    errorPolicy: "ignore" | "all";
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-    errorPolicy: "ignore" | "all";
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    errorPolicy: "ignore" | "all";
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    skip: boolean;
-    returnPartialData: false;
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    skip: boolean;
-    returnPartialData: boolean;
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: false;
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "partial">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    skip: boolean;
-}): [
-    QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): [undefined, useBackgroundQuery.Result<TData, TVariables>];
-/**
-* 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.
-*/
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: false;
-})): [
-    QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-})): [
-    QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: useBackgroundQuery.Options<NoInfer<TVariables>>
-] : [options: useBackgroundQuery.Options<NoInfer<TVariables>>]): [
-    QueryRef<TData, TVariables, "complete" | "streaming">,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>
-] : [options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>]): [
-    QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
-export declare function useBackgroundQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>): [
-    QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-    useBackgroundQuery.Result<TData, TVariables>
-];
+export declare const useBackgroundQuery: useBackgroundQuery.Signature;
 //# sourceMappingURL=useBackgroundQuery.d.ts.map