@apollo/client 4.2.0-alpha.5 → 4.2.0-alpha.6

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

@@ -299,10 +299,6 @@ export declare namespace useSuspenseQuery {
     }
     namespace Signatures {
         /**
-        * @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
@@ -344,6 +340,402 @@ export declare namespace useSuspenseQuery {
         * @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 Classic {
+            /**
+            * 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, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(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.
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, 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.
@@ -389,7 +781,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, 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">;
@@ -438,7 +830,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
                 errorPolicy: "ignore" | "all";
             }): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
             /**
@@ -486,7 +878,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, 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">;
@@ -535,7 +927,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: true;
             }): useSuspenseQuery.Result<TData, TVariables, "partial" | "streaming" | "complete">;
             /**
@@ -583,7 +975,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useSuspenseQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
             }): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
             /**
@@ -631,7 +1023,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useSuspenseQuery.Options<NoInfer<TVariables>> & {
+            <TData, 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">;
             /**
@@ -679,7 +1071,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+            <TData, 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">;
             /**
@@ -727,7 +1119,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+            <TData, 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">;
             /**
@@ -775,7 +1167,7 @@ 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.
             */
-            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useSuspenseQuery.Options<NoInfer<TVariables>>): useSuspenseQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+            <TData, 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).

package/__cjs/version.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.build = exports.version = void 0;
-exports.version = "4.2.0-alpha.5";
+exports.version = "4.2.0-alpha.6";
 exports.build = "cjs";
 //# sourceMappingURL=version.cjs.map

package/core/ApolloClient.d.ts

@@ -235,6 +235,17 @@ export declare namespace ApolloClient {
         type ResultForOptions<TData, TVariables extends OperationVariables, TCache extends ApolloCache, TOptions extends Record<string, unknown> | MutateOptions<any, TVariables, TCache>> = LazyType<MutateResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
+                /**
+                * This resolves a single mutation according to the options specified and returns a
+                * Promise which is either resolved with the resulting data or rejected with an
+                * error. In some cases both `data` and `errors` might be undefined, for example
+                * when `errorPolicy` is set to `'ignore'`.
+                * 
+                * It takes options as an object with the following keys and values:
+                */
+                <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: ApolloClient.MutateOptions<TData, TVariables, ApolloCache> & {
+                    errorPolicy?: TErrorPolicy;
+                }): Promise<ApolloClient.MutateResult<MaybeMasked<TData>, TErrorPolicy>>;
                 /**
                 * @deprecated Avoid manually specifying generics on `client.mutate`.
                 * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your mutation results.
@@ -247,7 +258,9 @@ export declare namespace ApolloClient {
                 * 
                 * It takes options as an object with the following keys and values:
                 */
-                <TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+                <TData, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache, TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: ApolloClient.MutateOptions<TData, TVariables, TCache> & (TErrorPolicy extends undefined ? {} : {
+                    errorPolicy: TErrorPolicy;
+                })): Promise<ApolloClient.MutateResult<MaybeMasked<TData>, TErrorPolicy>>;
             }
             interface Modern {
                 /**
@@ -463,6 +476,18 @@ export declare namespace ApolloClient {
         type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, unknown> | QueryOptions<any, TVariables>> = LazyType<QueryResult<MaybeMasked<TData>, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>>;
         namespace Signatures {
             interface Classic {
+                /**
+                * This resolves a single query according to the options specified and
+                * returns a `Promise` which is either resolved with the resulting data
+                * or rejected with an error.
+                * 
+                * @param options - An object of type `QueryOptions` that allows us to
+                * describe how this query should be treated e.g. whether it should hit the
+                * server at all or just resolve from the cache, etc.
+                */
+                <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: ApolloClient.QueryOptions<TData, TVariables> & {
+                    errorPolicy?: TErrorPolicy;
+                }): Promise<ApolloClient.QueryResult<MaybeMasked<TData>, TErrorPolicy>>;
                 /**
                 * @deprecated Avoid manually specifying generics on `client.query`.
                 * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
@@ -476,7 +501,9 @@ export declare namespace ApolloClient {
                 * describe how this query should be treated e.g. whether it should hit the
                 * server at all or just resolve from the cache, etc.
                 */
-                <TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
+                <TData, TVariables extends OperationVariables = OperationVariables, TErrorPolicy extends ErrorPolicy | undefined = undefined>(options: ApolloClient.QueryOptions<TData, TVariables> & (TErrorPolicy extends undefined ? {} : {
+                    errorPolicy: TErrorPolicy;
+                })): Promise<ApolloClient.QueryResult<MaybeMasked<TData>, TErrorPolicy>>;
             }
             interface Modern {
                 /**