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

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

@@ -1,4 +1,4 @@
-import type { ApolloClient, DataState, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, GetDataState, MaybeMasked, OperationVariables, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
+import type { ApolloClient, DataState, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, GetDataState, MaybeMasked, OperationVariables, RefetchOn, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import { NetworkStatus } from "@apollo/client";
 import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
@@ -71,6 +71,25 @@ export declare namespace useSuspenseQuery {
             */
             queryKey?: string | number | any[];
             /**
+            * Determines whether events trigger refetches for the query. Provide an
+            * object mapping each refetch event to `true` (enable), `false` (disable)
+            * or a callback function that returns `true`/`false` to control individual
+            * events. Provide `false` to disable all automatic refetch events for this
+            * query. Provide `true` to enable all automatic refetch events for this query.
+            * Provide a callback function to perform additional logic to determine
+            * whether to enable or disable a refetch for a query.
+            * 
+            * `@remarks`
+            * `refetchOn` inherits from `defaultOptions.watchQuery.refetchOn`. If
+            * `defaultOptions.watchQuery.refetchOn` is not set, all refetch events are
+            * enabled by default.
+            * 
+            * This option only has an effect when the client is configured with a
+            * `refetchEventManager`.
+            * @docGroup 1. Operation options
+            */
+            refetchOn?: RefetchOn.Option;
+            /**
             * If `true`, the query is not executed. The default value is `false`.
             * 
             * @deprecated We recommend using `skipToken` in place of the `skip` option as
@@ -185,138 +204,789 @@ export declare namespace useSuspenseQuery {
         }
     }
     namespace DocumentationTypes {
-        /**
-         * 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 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>;
         }
-        /**
-        * @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.
-        */
         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 {
         /**
+        * @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.
         */
         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;
@@ -325,7 +995,45 @@ export declare namespace useSuspenseQuery {
         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 {
     }