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

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

@@ -1,4 +1,4 @@
-import type { DataState, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, GetDataState, InternalTypes, ObservableQuery, OperationVariables, RefetchWritePolicy, SubscribeToMoreFunction, TypedDocumentNode, UpdateQueryMapFn, WatchQueryFetchPolicy } from "@apollo/client";
+import type { DataState, DefaultContext, DocumentNode, ErrorLike, ErrorPolicy, GetDataState, InternalTypes, ObservableQuery, OperationVariables, RefetchOn, RefetchWritePolicy, SubscribeToMoreFunction, TypedDocumentNode, UpdateQueryMapFn, WatchQueryFetchPolicy } from "@apollo/client";
 import type { ApolloClient } from "@apollo/client";
 import { NetworkStatus } from "@apollo/client";
 import type { MaybeMasked } from "@apollo/client/masking";
@@ -111,6 +111,25 @@ export declare namespace useQuery {
             * @docGroup 1. Operation options
             */
             skip?: boolean;
+            /**
+            * 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;
         }
     }
     type Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> = Base.Options<TData, TVariables> & VariablesOption<TVariables>;
@@ -237,94 +256,426 @@ export declare namespace useQuery {
         }
     }
     namespace DocumentationTypes {
-        /**
-         * A hook for executing queries in an Apollo application.
-         *
-         * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
-         *
-         * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
-         *
-         * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
-         *
-         * @example
-         *
-         * ```jsx
-         * import { gql } from "@apollo/client";
-         * import { useQuery } from "@apollo/client/react";
-         *
-         * const GET_GREETING = gql`
-         *   query GetGreeting($language: String!) {
-         *     greeting(language: $language) {
-         *       message
-         *     }
-         *   }
-         * `;
-         *
-         * function Hello() {
-         *   const { loading, error, data } = useQuery(GET_GREETING, {
-         *     variables: { language: "english" },
-         *   });
-         *   if (loading) return <p>Loading ...</p>;
-         *   return <h1>Hello {data.greeting.message}!</h1>;
-         * }
-         * ```
-         *
-         * @param query - A GraphQL query document parsed into an AST by `gql`.
-         * @param options - Options to control how the query is executed.
-         * @returns Query result object
-         */
         interface useQuery {
+            /**
+             * A hook for executing queries in an Apollo application.
+             *
+             * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+             *
+             * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+             *
+             * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+             *
+             * @example
+             *
+             * ```jsx
+             * import { gql } from "@apollo/client";
+             * import { useQuery } from "@apollo/client/react";
+             *
+             * const GET_GREETING = gql`
+             *   query GetGreeting($language: String!) {
+             *     greeting(language: $language) {
+             *       message
+             *     }
+             *   }
+             * `;
+             *
+             * function Hello() {
+             *   const { loading, error, data } = useQuery(GET_GREETING, {
+             *     variables: { language: "english" },
+             *   });
+             *   if (loading) return <p>Loading ...</p>;
+             *   return <h1>Hello {data.greeting.message}!</h1>;
+             * }
+             * ```
+             *
+             * @param query - A GraphQL query document parsed into an AST by `gql`.
+             * @param options - Options to control how the query is executed.
+             * @returns Query result object
+             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
         }
-        /**
-        * @deprecated Avoid manually specifying generics on `useQuery`.
-        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
-        */
         interface useQuery_Deprecated {
+            /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            *
+            *
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
+            */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<TData, TVariables>): useQuery.Result<TData, TVariables>;
         }
     }
     namespace Signatures {
         /**
+        * @deprecated Avoid manually specifying generics on `useQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        * 
+        * 
+        * A hook for executing queries in an Apollo application.
+        * 
+        * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+        * 
+        * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+        * 
+        * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
         * 
+        * @example
+        * 
+        * ```jsx
+        * import { gql } from "@apollo/client";
+        * import { useQuery } from "@apollo/client/react";
+        * 
+        * const GET_GREETING = gql`
+        *   query GetGreeting($language: String!) {
+        *     greeting(language: $language) {
+        *       message
+        *     }
+        *   }
+        * `;
+        * 
+        * function Hello() {
+        *   const { loading, error, data } = useQuery(GET_GREETING, {
+        *     variables: { language: "english" },
+        *   });
+        *   if (loading) return <p>Loading ...</p>;
+        *   return <h1>Hello {data.greeting.message}!</h1>;
+        * }
+        * ```
+        * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - Options to control how the query is executed.
+        * @returns Query result object
         */
         interface Classic {
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
             * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
                 returnPartialData: true;
             }): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
             * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
             * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
                 returnPartialData: true;
             })): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
             * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
                 returnPartialData: boolean;
             }): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
             * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
                 returnPartialData: boolean;
             })): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming" | "partial", Partial<TVariables>>;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for executing queries in an Apollo application.
             * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                 options?: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
             ] : [options: useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>]): useQuery.Result<TData, TVariables, "empty" | "complete" | "streaming">;
             /**
+            * @deprecated Avoid manually specifying generics on `useQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
             * 
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
                 options?: SkipToken | useQuery.Options<NoInfer<TData>, NoInfer<TVariables>>
@@ -334,19 +685,151 @@ export declare namespace useQuery {
             ssrDisabledResult: ObservableQuery.Result<any>;
         }
         /**
+        * A hook for executing queries in an Apollo application.
+        * 
+        * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
         * 
+        * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+        * 
+        * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { gql } from "@apollo/client";
+        * import { useQuery } from "@apollo/client/react";
+        * 
+        * const GET_GREETING = gql`
+        *   query GetGreeting($language: String!) {
+        *     greeting(language: $language) {
+        *       message
+        *     }
+        *   }
+        * `;
+        * 
+        * function Hello() {
+        *   const { loading, error, data } = useQuery(GET_GREETING, {
+        *     variables: { language: "english" },
+        *   });
+        *   if (loading) return <p>Loading ...</p>;
+        *   return <h1>Hello {data.greeting.message}!</h1>;
+        * }
+        * ```
+        * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - Options to control how the query is executed.
+        * @returns Query result object
         */
         interface Modern {
             /**
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
             * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData, TVariables extends OperationVariables, Options extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): useQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
             /**
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
             * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData, TVariables extends OperationVariables, TOptions extends SkipToken>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken): useQuery.Result<TData, TVariables, "empty", Record<string, never>>;
             /**
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
             * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData, TVariables extends OperationVariables, TOptions extends useQuery.Options<TData, NoInfer<TVariables>> & VariablesOption<TVariables & {
                 [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
@@ -356,7 +839,40 @@ export declare namespace useQuery {
                 options: TOptions
             ]): useQuery.ResultForOptions<TData, TVariables, TOptions>;
             /**
+            * A hook for executing queries in an Apollo application.
+            * 
+            * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+            * 
+            * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+            * 
+            * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
             * 
+            * function Hello() {
+            *   const { loading, error, data } = useQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (loading) return <p>Loading ...</p>;
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns Query result object
             */
             <TData, TVariables extends OperationVariables, TOptions extends useQuery.Options<TData, NoInfer<TVariables>> & VariablesOption<TVariables & {
                 [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
@@ -370,7 +886,40 @@ export declare namespace useQuery {
         type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
     }
     /**
+    * A hook for executing queries in an Apollo application.
+    * 
+    * To run a query within a React component, call `useQuery` and pass it a GraphQL query document.
+    * 
+    * When your component renders, `useQuery` returns an object from Apollo Client that contains `loading`, `error`, `dataState`, and `data` properties you can use to render your UI.
+    * 
+    * > Refer to the [Queries](https://www.apollographql.com/docs/react/data/queries) section for a more in-depth overview of `useQuery`.
+    * 
+    * @example
+    * 
+    * ```jsx
+    * import { gql } from "@apollo/client";
+    * import { useQuery } from "@apollo/client/react";
+    * 
+    * const GET_GREETING = gql`
+    *   query GetGreeting($language: String!) {
+    *     greeting(language: $language) {
+    *       message
+    *     }
+    *   }
+    * `;
+    * 
+    * function Hello() {
+    *   const { loading, error, data } = useQuery(GET_GREETING, {
+    *     variables: { language: "english" },
+    *   });
+    *   if (loading) return <p>Loading ...</p>;
+    *   return <h1>Hello {data.greeting.message}!</h1>;
+    * }
+    * ```
     * 
+    * @param query - A GraphQL query document parsed into an AST by `gql`.
+    * @param options - Options to control how the query is executed.
+    * @returns Query result object
     */
     interface Signature extends Signatures.Evaluated {
     }