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

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

@@ -2,6 +2,7 @@ import type { ApolloClient, DataState, DefaultContext, DocumentNode, ErrorPolicy
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import type { QueryRef } from "@apollo/client/react";
 import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
+import type { OptionWithFallback, SignatureStyle } from "@apollo/client/utilities/internal";
 type ResetFunction = () => void;
 export declare namespace useLoadableQuery {
     type LoadQueryFunction<TVariables extends OperationVariables> = (...args: {} extends TVariables ? [variables?: TVariables] : [variables: TVariables]) => void;
@@ -109,7 +110,370 @@ export declare namespace useLoadableQuery {
         */
         returnPartialData?: boolean;
     }
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options> = Result<TData, TVariables, "complete" | "streaming" | (OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> extends ("none") ? never : "empty") | (OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial")>;
     namespace DocumentationTypes {
+        interface useLoadableQuery {
+            /**
+             * A hook for imperatively loading a query, such as responding to a user
+             * interaction.
+             *
+             * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+             *
+             * @example
+             *
+             * ```jsx
+             * import { gql, useLoadableQuery } from "@apollo/client";
+             *
+             * const GET_GREETING = gql`
+             *   query GetGreeting($language: String!) {
+             *     greeting(language: $language) {
+             *       message
+             *     }
+             *   }
+             * `;
+             *
+             * function App() {
+             *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+             *
+             *   return (
+             *     <>
+             *       <button onClick={() => loadGreeting({ language: "english" })}>
+             *         Load greeting
+             *       </button>
+             *       <Suspense fallback={<div>Loading...</div>}>
+             *         {queryRef && <Hello queryRef={queryRef} />}
+             *       </Suspense>
+             *     </>
+             *   );
+             * }
+             *
+             * function Hello({ queryRef }) {
+             *   const { data } = useReadQuery(queryRef);
+             *
+             *   return <div>{data.greeting.message}</div>;
+             * }
+             * ```
+             *
+             * @param query - A GraphQL query document parsed into an AST by `gql`.
+             * @param options - Options to control how the query is executed.
+             * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+             */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables>;
+        }
+        interface useLoadableQuery_Deprecated {
+            /**
+            * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            *
+            *
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables>;
+        }
+    }
+    namespace Signatures {
+        /**
+        * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        * 
+        * 
+        * A hook for imperatively loading a query, such as responding to a user
+        * interaction.
+        * 
+        * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { gql, useLoadableQuery } from "@apollo/client";
+        * 
+        * const GET_GREETING = gql`
+        *   query GetGreeting($language: String!) {
+        *     greeting(language: $language) {
+        *       message
+        *     }
+        *   }
+        * `;
+        * 
+        * function App() {
+        *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+        * 
+        *   return (
+        *     <>
+        *       <button onClick={() => loadGreeting({ language: "english" })}>
+        *         Load greeting
+        *       </button>
+        *       <Suspense fallback={<div>Loading...</div>}>
+        *         {queryRef && <Hello queryRef={queryRef} />}
+        *       </Suspense>
+        *     </>
+        *   );
+        * }
+        * 
+        * function Hello({ queryRef }) {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   return <div>{data.greeting.message}</div>;
+        * }
+        * ```
+        * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - Options to control how the query is executed.
+        * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+        */
+        interface Classic {
+            /**
+            * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
+                errorPolicy: "ignore" | "all";
+            }): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
+                returnPartialData: true;
+            }): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generics on `useLoadableQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming">;
+        }
         /**
         * A hook for imperatively loading a query, such as responding to a user
         * interaction.
@@ -155,199 +519,150 @@ export declare namespace useLoadableQuery {
         * @param options - Options to control how the query is executed.
         * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
         */
-        function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables>;
+        interface Modern {
+            /**
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends never>(query: DocumentNode | TypedDocumentNode<TData, TVariables>): useLoadableQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * A hook for imperatively loading a query, such as responding to a user
+            * interaction.
+            * 
+            * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql, useLoadableQuery } from "@apollo/client";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function App() {
+            *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+            * 
+            *   return (
+            *     <>
+            *       <button onClick={() => loadGreeting({ language: "english" })}>
+            *         Load greeting
+            *       </button>
+            *       <Suspense fallback={<div>Loading...</div>}>
+            *         {queryRef && <Hello queryRef={queryRef} />}
+            *       </Suspense>
+            *     </>
+            *   );
+            * }
+            * 
+            * function Hello({ queryRef }) {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   return <div>{data.greeting.message}</div>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Options to control how the query is executed.
+            * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useLoadableQuery.Options>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: TOptions): useLoadableQuery.ResultForOptions<TData, TVariables, TOptions>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+    /**
+    * A hook for imperatively loading a query, such as responding to a user
+    * interaction.
+    * 
+    * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
+    * 
+    * @example
+    * 
+    * ```jsx
+    * import { gql, useLoadableQuery } from "@apollo/client";
+    * 
+    * const GET_GREETING = gql`
+    *   query GetGreeting($language: String!) {
+    *     greeting(language: $language) {
+    *       message
+    *     }
+    *   }
+    * `;
+    * 
+    * function App() {
+    *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
+    * 
+    *   return (
+    *     <>
+    *       <button onClick={() => loadGreeting({ language: "english" })}>
+    *         Load greeting
+    *       </button>
+    *       <Suspense fallback={<div>Loading...</div>}>
+    *         {queryRef && <Hello queryRef={queryRef} />}
+    *       </Suspense>
+    *     </>
+    *   );
+    * }
+    * 
+    * function Hello({ queryRef }) {
+    *   const { data } = useReadQuery(queryRef);
+    * 
+    *   return <div>{data.greeting.message}</div>;
+    * }
+    * ```
+    * 
+    * @param query - A GraphQL query document parsed into an AST by `gql`.
+    * @param options - Options to control how the query is executed.
+    * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
+    */
+    interface Signature extends Signatures.Evaluated {
     }
 }
-/**
- * A hook for imperatively loading a query, such as responding to a user
- * interaction.
- *
- * > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
- *
- * @example
- *
- * ```jsx
- * import { gql, useLoadableQuery } from "@apollo/client";
- *
- * const GET_GREETING = gql`
- *   query GetGreeting($language: String!) {
- *     greeting(language: $language) {
- *       message
- *     }
- *   }
- * `;
- *
- * function App() {
- *   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
- *
- *   return (
- *     <>
- *       <button onClick={() => loadGreeting({ language: "english" })}>
- *         Load greeting
- *       </button>
- *       <Suspense fallback={<div>Loading...</div>}>
- *         {queryRef && <Hello queryRef={queryRef} />}
- *       </Suspense>
- *     </>
- *   );
- * }
- *
- * function Hello({ queryRef }) {
- *   const { data } = useReadQuery(queryRef);
- *
- *   return <div>{data.greeting.message}</div>;
- * }
- * ```
- *
- * @param query - A GraphQL query document parsed into an AST by `gql`.
- * @param options - Options to control how the query is executed.
- * @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
- */
-export declare function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
-    returnPartialData: true;
-    errorPolicy: "ignore" | "all";
-}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
-/**
-* A hook for imperatively loading a query, such as responding to a user
-* interaction.
-* 
-* > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql, useLoadableQuery } from "@apollo/client";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
-* 
-*   return (
-*     <>
-*       <button onClick={() => loadGreeting({ language: "english" })}>
-*         Load greeting
-*       </button>
-*       <Suspense fallback={<div>Loading...</div>}>
-*         {queryRef && <Hello queryRef={queryRef} />}
-*       </Suspense>
-*     </>
-*   );
-* }
-* 
-* function Hello({ queryRef }) {
-*   const { data } = useReadQuery(queryRef);
-* 
-*   return <div>{data.greeting.message}</div>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
-*/
-export declare function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
-    errorPolicy: "ignore" | "all";
-}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "empty">;
-/**
-* A hook for imperatively loading a query, such as responding to a user
-* interaction.
-* 
-* > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql, useLoadableQuery } from "@apollo/client";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
-* 
-*   return (
-*     <>
-*       <button onClick={() => loadGreeting({ language: "english" })}>
-*         Load greeting
-*       </button>
-*       <Suspense fallback={<div>Loading...</div>}>
-*         {queryRef && <Hello queryRef={queryRef} />}
-*       </Suspense>
-*     </>
-*   );
-* }
-* 
-* function Hello({ queryRef }) {
-*   const { data } = useReadQuery(queryRef);
-* 
-*   return <div>{data.greeting.message}</div>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
-*/
-export declare function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLoadableQuery.Options & {
-    returnPartialData: true;
-}): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming" | "partial">;
-/**
-* A hook for imperatively loading a query, such as responding to a user
-* interaction.
-* 
-* > Refer to the [Suspense - Fetching in response to user interaction](https://www.apollographql.com/docs/react/data/suspense#fetching-in-response-to-user-interaction) section for a more in-depth overview of `useLoadableQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql, useLoadableQuery } from "@apollo/client";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function App() {
-*   const [loadGreeting, queryRef] = useLoadableQuery(GET_GREETING);
-* 
-*   return (
-*     <>
-*       <button onClick={() => loadGreeting({ language: "english" })}>
-*         Load greeting
-*       </button>
-*       <Suspense fallback={<div>Loading...</div>}>
-*         {queryRef && <Hello queryRef={queryRef} />}
-*       </Suspense>
-*     </>
-*   );
-* }
-* 
-* function Hello({ queryRef }) {
-*   const { data } = useReadQuery(queryRef);
-* 
-*   return <div>{data.greeting.message}</div>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Options to control how the query is executed.
-* @returns A tuple in the form of `[loadQuery, queryRef, handlers]`
-*/
-export declare function useLoadableQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLoadableQuery.Options): useLoadableQuery.Result<TData, TVariables, "complete" | "streaming">;
+export declare const useLoadableQuery: useLoadableQuery.Signature;
 export {};
 //# sourceMappingURL=useLoadableQuery.d.cts.map