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

package/__cjs/react/hooks/useSuspenseQuery.d.cts

@@ -2,7 +2,7 @@ import type { ApolloClient, DataState, DefaultContext, DocumentNode, ErrorLike,
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import { NetworkStatus } from "@apollo/client";
 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.cjs";
 export declare namespace useSuspenseQuery {
     type FetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
@@ -172,6 +172,12 @@ export declare namespace useSuspenseQuery {
         }
     }
     type Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TStates extends DataState<TData>["dataState"] = DataState<TData>["dataState"]> = Base.Result<TData, TVariables> & GetDataState<MaybeMasked<TData>, TStates>;
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+        skip: false;
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options<TVariables> | SkipToken> = Result<TData, TVariables, "complete" | "streaming" | (TOptions extends any ? TOptions extends SkipToken ? "empty" : (OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> extends "none" ? never : "empty") | (OptionWithFallback<TOptions, DefaultOptions, "skip"> extends (false) ? never : "empty") | (OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial") : never) | ([TOptions] extends [SkipToken] ? DefaultOptions extends {
+        returnPartialData: false;
+    } ? never : "partial" : never)>;
     namespace DocumentationTypes {
         namespace useSuspenseQuery {
             interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> extends Base.Result<TData, TVariables>, UtilityDocumentationTypes.DataState<TData> {
@@ -179,8 +185,105 @@ export declare namespace useSuspenseQuery {
         }
     }
     namespace DocumentationTypes {
+        interface useSuspenseQuery {
+            /**
+             * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+             *
+             * @example
+             *
+             * ```jsx
+             * import { Suspense } from "react";
+             * import { useSuspenseQuery } from "@apollo/client";
+             *
+             * const listQuery = gql`
+             *   query {
+             *     list {
+             *       id
+             *     }
+             *   }
+             * `;
+             *
+             * function App() {
+             *   return (
+             *     <Suspense fallback={<Spinner />}>
+             *       <List />
+             *     </Suspense>
+             *   );
+             * }
+             *
+             * function List() {
+             *   const { data } = useSuspenseQuery(listQuery);
+             *
+             *   return (
+             *     <ol>
+             *       {data.list.map((item) => (
+             *         <Item key={item.id} id={item.id} />
+             *       ))}
+             *     </ol>
+             *   );
+             * }
+             * ```
+             *
+             * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+             */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useSuspenseQuery.Options<TVariables>): useSuspenseQuery.Result<TData, TVariables>;
+        }
+        interface useSuspenseQuery_Deprecated {
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useSuspenseQuery.Options<TVariables>): useSuspenseQuery.Result<TData, TVariables>;
+        }
+    }
+    namespace Signatures {
         /**
-        * Test 
+        * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+        * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
         * 
         * @example
@@ -221,405 +324,702 @@ export declare namespace useSuspenseQuery {
         * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
         */
-        function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useSuspenseQuery.Options<TVariables>): useSuspenseQuery.Result<TData, TVariables>;
+        interface Classic {
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                errorPolicy: "ignore" | "all";
+            }): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                skip: boolean;
+                returnPartialData: true;
+            }): useSuspenseQuery.Result<TData, TVariables, "complete" | "empty" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): useSuspenseQuery.Result<TData, TVariables, "partial" | "streaming" | "complete">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                skip: boolean;
+            }): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useSuspenseQuery.Options<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            })): useSuspenseQuery.Result<TData, TVariables, "empty" | "streaming" | "complete" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: useSuspenseQuery.Options<NoInfer<TVariables>>
+            ] : [options: useSuspenseQuery.Options<NoInfer<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>
+            ] : [options: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generic arguments on `useSuspenseQuery`.
+            * 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 `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+        }
+        /**
+        * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { Suspense } from "react";
+        * import { useSuspenseQuery } from "@apollo/client";
+        * 
+        * const listQuery = gql`
+        *   query {
+        *     list {
+        *       id
+        *     }
+        *   }
+        * `;
+        * 
+        * function App() {
+        *   return (
+        *     <Suspense fallback={<Spinner />}>
+        *       <List />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function List() {
+        *   const { data } = useSuspenseQuery(listQuery);
+        * 
+        *   return (
+        *     <ol>
+        *       {data.list.map((item) => (
+        *         <Item key={item.id} id={item.id} />
+        *       ))}
+        *     </ol>
+        *   );
+        * }
+        * ```
+        * 
+        * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+        */
+        interface Modern {
+            /**
+            * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData, TVariables extends OperationVariables, Options extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): useSuspenseQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends never>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, skipToken: SkipToken): useSuspenseQuery.ResultForOptions<TData, TVariables, SkipToken>;
+            /**
+            * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useSuspenseQuery.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]): useSuspenseQuery.ResultForOptions<TData, TVariables, TOptions>;
+            /**
+            * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { Suspense } from "react";
+            * import { useSuspenseQuery } from "@apollo/client";
+            * 
+            * const listQuery = gql`
+            *   query {
+            *     list {
+            *       id
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<Spinner />}>
+            *       <List />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function List() {
+            *   const { data } = useSuspenseQuery(listQuery);
+            * 
+            *   return (
+            *     <ol>
+            *       {data.list.map((item) => (
+            *         <Item key={item.id} id={item.id} />
+            *       ))}
+            *     </ol>
+            *   );
+            * }
+            * ```
+            * 
+            * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useSuspenseQuery.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]): useSuspenseQuery.ResultForOptions<TData, TVariables, TOptions | SkipToken>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+    /**
+    * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
+    * 
+    * @example
+    * 
+    * ```jsx
+    * import { Suspense } from "react";
+    * import { useSuspenseQuery } from "@apollo/client";
+    * 
+    * const listQuery = gql`
+    *   query {
+    *     list {
+    *       id
+    *     }
+    *   }
+    * `;
+    * 
+    * function App() {
+    *   return (
+    *     <Suspense fallback={<Spinner />}>
+    *       <List />
+    *     </Suspense>
+    *   );
+    * }
+    * 
+    * function List() {
+    *   const { data } = useSuspenseQuery(listQuery);
+    * 
+    *   return (
+    *     <ol>
+    *       {data.list.map((item) => (
+    *         <Item key={item.id} id={item.id} />
+    *       ))}
+    *     </ol>
+    *   );
+    * }
+    * ```
+    * 
+    * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
+    */
+    interface Signature extends Signatures.Evaluated {
     }
 }
-/**
- * For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
- *
- * @example
- *
- * ```jsx
- * import { Suspense } from "react";
- * import { useSuspenseQuery } from "@apollo/client";
- *
- * const listQuery = gql`
- *   query {
- *     list {
- *       id
- *     }
- *   }
- * `;
- *
- * function App() {
- *   return (
- *     <Suspense fallback={<Spinner />}>
- *       <List />
- *     </Suspense>
- *   );
- * }
- *
- * function List() {
- *   const { data } = useSuspenseQuery(listQuery);
- *
- *   return (
- *     <ol>
- *       {data.list.map((item) => (
- *         <Item key={item.id} id={item.id} />
- *       ))}
- *     </ol>
- *   );
- * }
- * ```
- *
- * @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
- */
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: true;
-    errorPolicy: "ignore" | "all";
-}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    errorPolicy: "ignore" | "all";
-}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    skip: boolean;
-    returnPartialData: true;
-}): useSuspenseQuery.Result<TData, TVariables, "complete" | "empty" | "streaming" | "partial">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: true;
-}): useSuspenseQuery.Result<TData, TVariables, "partial" | "streaming" | "complete">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    skip: boolean;
-}): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useSuspenseQuery.Options<NoInfer<TVariables>> & {
-    returnPartialData: true;
-})): useSuspenseQuery.Result<TData, TVariables, "empty" | "streaming" | "complete" | "partial">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: useSuspenseQuery.Options<NoInfer<TVariables>>
-] : [options: useSuspenseQuery.Options<NoInfer<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-    options?: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>
-] : [options: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>]): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
-/**
-* For a detailed explanation of `useSuspenseQuery`, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
-* 
-* @example
-* 
-* ```jsx
-* import { Suspense } from "react";
-* import { useSuspenseQuery } from "@apollo/client";
-* 
-* const listQuery = gql`
-*   query {
-*     list {
-*       id
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   return (
-*     <Suspense fallback={<Spinner />}>
-*       <List />
-*     </Suspense>
-*   );
-* }
-* 
-* function List() {
-*   const { data } = useSuspenseQuery(listQuery);
-* 
-*   return (
-*     <ol>
-*       {data.list.map((item) => (
-*         <Item key={item.id} id={item.id} />
-*       ))}
-*     </ol>
-*   );
-* }
-* ```
-* 
-* @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 `useSuspenseQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useSuspenseQuery` hook from executing the query or suspending.
-*/
-export declare function useSuspenseQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+export declare const useSuspenseQuery: useSuspenseQuery.Signature;
 interface UseWatchQueryOptionsHookOptions<TData, TVariables extends OperationVariables> {
     client: ApolloClient;
     query: DocumentNode | TypedDocumentNode<TData, TVariables>;