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

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

@@ -2,7 +2,7 @@ import type { TypedDocumentNode } from "@graphql-typed-document-node/core";
 import type { DocumentNode } from "graphql";
 import type { ApolloClient, DataState, DefaultContext, ErrorLike, ErrorPolicy, GetDataState, InternalTypes, MaybeMasked, ObservableQuery, OperationVariables, RefetchWritePolicy, SubscribeToMoreFunction, UpdateQueryMapFn, WatchQueryFetchPolicy } from "@apollo/client";
 import { NetworkStatus } from "@apollo/client";
-import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, VariablesOption } from "@apollo/client/utilities/internal";
+import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 export declare namespace useLazyQuery {
     import _self = useLazyQuery;
     interface Options<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
@@ -279,11 +279,100 @@ export declare namespace useLazyQuery {
     ] : [options: useLazyQuery.ExecOptions<TVariables>]) => ObservableQuery.ResultPromise<ApolloClient.QueryResult<TData>>;
     namespace DocumentationTypes {
         namespace useLazyQuery {
-            export import ResultTuple = _self.ResultTuple;
+            export type { ResultTuple };
         }
     }
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options<TData, TVariables>> = ResultTuple<TData, TVariables, "complete" | "streaming" | "empty" | (OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial")>;
     namespace DocumentationTypes {
+        interface useLazyQuery {
+            /**
+             * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
+             *
+             * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+             *
+             * @example
+             *
+             * ```jsx
+             * import { gql } from "@apollo/client";
+             * import { useLazyQuery } from "@apollo/client/react";
+             *
+             * const GET_GREETING = gql`
+             *   query GetGreeting($language: String!) {
+             *     greeting(language: $language) {
+             *       message
+             *     }
+             *   }
+             * `;
+             *
+             * function Hello() {
+             *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+             *     variables: { language: "english" },
+             *   });
+             *   if (called && loading) return <p>Loading ...</p>;
+             *   if (!called) {
+             *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+             *   }
+             *   return <h1>Hello {data.greeting.message}!</h1>;
+             * }
+             * ```
+             *
+             * @param query - A GraphQL query document parsed into an AST by `gql`.
+             * @param options - Default options to control how the query is executed.
+             * @returns A tuple in the form of `[execute, result]`
+             */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<TData, TVariables>): useLazyQuery.ResultTuple<TData, TVariables>;
+        }
+        interface useLazyQuery_Deprecated {
+            /**
+            * @deprecated Avoid manually specifying generics on `useLazyQuery`.
+            * 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 executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<TData, TVariables>): useLazyQuery.ResultTuple<TData, TVariables>;
+        }
+    }
+    namespace Signatures {
         /**
+        * @deprecated Avoid manually specifying generics on `useLazyQuery`.
+        * 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 executing queries in an Apollo application, e.g. in response to user interaction.
         * 
         * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
@@ -318,119 +407,284 @@ export declare namespace useLazyQuery {
         * @param options - Default options to control how the query is executed.
         * @returns A tuple in the form of `[execute, result]`
         */
-        function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<TData, TVariables>): useLazyQuery.ResultTuple<TData, TVariables>;
+        interface Classic {
+            /**
+            * @deprecated Avoid manually specifying generics on `useLazyQuery`.
+            * 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 executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generics on `useLazyQuery`.
+            * 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 executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                returnPartialData: boolean;
+            }): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generics on `useLazyQuery`.
+            * 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 executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>>): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming">;
+        }
+        /**
+        * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
+        * 
+        * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+        * 
+        * @example
+        * 
+        * ```jsx
+        * import { gql } from "@apollo/client";
+        * import { useLazyQuery } from "@apollo/client/react";
+        * 
+        * const GET_GREETING = gql`
+        *   query GetGreeting($language: String!) {
+        *     greeting(language: $language) {
+        *       message
+        *     }
+        *   }
+        * `;
+        * 
+        * function Hello() {
+        *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+        *     variables: { language: "english" },
+        *   });
+        *   if (called && loading) return <p>Loading ...</p>;
+        *   if (!called) {
+        *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+        *   }
+        *   return <h1>Hello {data.greeting.message}!</h1>;
+        * }
+        * ```
+        * 
+        * @param query - A GraphQL query document parsed into an AST by `gql`.
+        * @param options - Default options to control how the query is executed.
+        * @returns A tuple in the form of `[execute, result]`
+        */
+        interface Modern {
+            /**
+            * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends never>(query: DocumentNode | TypedDocumentNode<TData, TVariables>): useLazyQuery.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
+            * 
+            * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+            * 
+            * @example
+            * 
+            * ```jsx
+            * import { gql } from "@apollo/client";
+            * import { useLazyQuery } from "@apollo/client/react";
+            * 
+            * const GET_GREETING = gql`
+            *   query GetGreeting($language: String!) {
+            *     greeting(language: $language) {
+            *       message
+            *     }
+            *   }
+            * `;
+            * 
+            * function Hello() {
+            *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+            *     variables: { language: "english" },
+            *   });
+            *   if (called && loading) return <p>Loading ...</p>;
+            *   if (!called) {
+            *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+            *   }
+            *   return <h1>Hello {data.greeting.message}!</h1>;
+            * }
+            * ```
+            * 
+            * @param query - A GraphQL query document parsed into an AST by `gql`.
+            * @param options - Default options to control how the query is executed.
+            * @returns A tuple in the form of `[execute, result]`
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
+                variables?: {
+                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+                };
+            }>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: TOptions): useLazyQuery.ResultForOptions<TData, TVariables, TOptions>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+    /**
+    * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
+    * 
+    * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
+    * 
+    * @example
+    * 
+    * ```jsx
+    * import { gql } from "@apollo/client";
+    * import { useLazyQuery } from "@apollo/client/react";
+    * 
+    * const GET_GREETING = gql`
+    *   query GetGreeting($language: String!) {
+    *     greeting(language: $language) {
+    *       message
+    *     }
+    *   }
+    * `;
+    * 
+    * function Hello() {
+    *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
+    *     variables: { language: "english" },
+    *   });
+    *   if (called && loading) return <p>Loading ...</p>;
+    *   if (!called) {
+    *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
+    *   }
+    *   return <h1>Hello {data.greeting.message}!</h1>;
+    * }
+    * ```
+    * 
+    * @param query - A GraphQL query document parsed into an AST by `gql`.
+    * @param options - Default options to control how the query is executed.
+    * @returns A tuple in the form of `[execute, result]`
+    */
+    interface Signature extends Signatures.Evaluated {
     }
 }
-/**
- * A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
- *
- * > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
- *
- * @example
- *
- * ```jsx
- * import { gql } from "@apollo/client";
- * import { useLazyQuery } from "@apollo/client/react";
- *
- * const GET_GREETING = gql`
- *   query GetGreeting($language: String!) {
- *     greeting(language: $language) {
- *       message
- *     }
- *   }
- * `;
- *
- * function Hello() {
- *   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
- *     variables: { language: "english" },
- *   });
- *   if (called && loading) return <p>Loading ...</p>;
- *   if (!called) {
- *     return <button onClick={() => loadGreeting()}>Load greeting</button>;
- *   }
- *   return <h1>Hello {data.greeting.message}!</h1>;
- * }
- * ```
- *
- * @param query - A GraphQL query document parsed into an AST by `gql`.
- * @param options - Default options to control how the query is executed.
- * @returns A tuple in the form of `[execute, result]`
- */
-export declare function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: true;
-}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
-/**
-* A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
-* 
-* > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useLazyQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (called && loading) return <p>Loading ...</p>;
-*   if (!called) {
-*     return <button onClick={() => loadGreeting()}>Load greeting</button>;
-*   }
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Default options to control how the query is executed.
-* @returns A tuple in the form of `[execute, result]`
-*/
-export declare function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>> & {
-    returnPartialData: boolean;
-}): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming" | "partial">;
-/**
-* A hook for imperatively executing queries in an Apollo application, e.g. in response to user interaction.
-* 
-* > Refer to the [Queries - Manual execution with useLazyQuery](https://www.apollographql.com/docs/react/data/queries#manual-execution-with-uselazyquery) section for a more in-depth overview of `useLazyQuery`.
-* 
-* @example
-* 
-* ```jsx
-* import { gql } from "@apollo/client";
-* import { useLazyQuery } from "@apollo/client/react";
-* 
-* const GET_GREETING = gql`
-*   query GetGreeting($language: String!) {
-*     greeting(language: $language) {
-*       message
-*     }
-*   }
-* `;
-* 
-* function Hello() {
-*   const [loadGreeting, { called, loading, data }] = useLazyQuery(GET_GREETING, {
-*     variables: { language: "english" },
-*   });
-*   if (called && loading) return <p>Loading ...</p>;
-*   if (!called) {
-*     return <button onClick={() => loadGreeting()}>Load greeting</button>;
-*   }
-*   return <h1>Hello {data.greeting.message}!</h1>;
-* }
-* ```
-* 
-* @param query - A GraphQL query document parsed into an AST by `gql`.
-* @param options - Default options to control how the query is executed.
-* @returns A tuple in the form of `[execute, result]`
-*/
-export declare function useLazyQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options?: useLazyQuery.Options<NoInfer<TData>, NoInfer<TVariables>>): useLazyQuery.ResultTuple<TData, TVariables, "empty" | "complete" | "streaming">;
+export declare const useLazyQuery: useLazyQuery.Signature;
 //# sourceMappingURL=useLazyQuery.d.cts.map

package/__cjs/react/hooks/useLoadableQuery.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useLoadableQuery = useLoadableQuery;
+exports.useLoadableQuery = void 0;
 const tslib_1 = require("tslib");
 const React = tslib_1.__importStar(require("react"));
 const cache_1 = require("@apollo/client/cache");
@@ -10,7 +10,7 @@ const invariant_1 = require("@apollo/client/utilities/invariant");
 const index_js_1 = require("./internal/index.cjs");
 const validateSuspenseHookOptions_js_1 = require("./internal/validateSuspenseHookOptions.cjs");
 const useApolloClient_js_1 = require("./useApolloClient.cjs");
-function useLoadableQuery(query, options = {}) {
+exports.useLoadableQuery = function useLoadableQuery(query, options = {}) {
     const client = (0, useApolloClient_js_1.useApolloClient)(options.client);
     const suspenseCache = (0, internal_1.getSuspenseCache)(client);
     const watchQueryOptions = useWatchQueryOptions({ client, query, options });
@@ -69,8 +69,12 @@ function useLoadableQuery(query, options = {}) {
     const reset = React.useCallback(() => {
         setQueryRef(null);
     }, []);
-    return [loadQuery, queryRef, { fetchMore, refetch, reset, subscribeToMore }];
-}
+    return [
+        loadQuery,
+        queryRef,
+        { fetchMore, refetch, reset, subscribeToMore },
+    ];
+};
 function useWatchQueryOptions({ client, query, options, }) {
     return (0, index_js_1.useDeepMemo)(() => {
         const fetchPolicy = options.fetchPolicy ||