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

package/__cjs/react/query-preloader/createQueryPreloader.d.cts

@@ -1,6 +1,6 @@
 import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, OperationVariables, RefetchOn, RefetchWritePolicy, TypedDocumentNode, WatchQueryFetchPolicy } from "@apollo/client";
 import type { PreloadedQueryRef } from "@apollo/client/react";
-import type { NoInfer, VariablesOption } from "@apollo/client/utilities/internal";
+import type { NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 export type PreloadQueryFetchPolicy = Extract<WatchQueryFetchPolicy, "cache-first" | "network-only" | "no-cache" | "cache-and-network">;
 export type PreloadQueryOptions<TVariables extends OperationVariables = OperationVariables> = {
     /**
@@ -93,128 +93,7 @@ export type PreloadQueryOptions<TVariables extends OperationVariables = Operatio
  * }
  * ```
  */
-export interface PreloadQueryFunction {
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        returnPartialData: true;
-        errorPolicy: "ignore" | "all";
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        errorPolicy: "ignore" | "all";
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
-        returnPartialData: true;
-    }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
-    /**
-    * A function that will begin loading a query when called. It's result can be
-    * read by `useReadQuery` which will suspend until the query is loaded.
-    * This is useful when you want to start loading a query as early as possible
-    * outside of a React component.
-    * 
-    * @example
-    * 
-    * ```js
-    * const preloadQuery = createQueryPreloader(client);
-    * const queryRef = preloadQuery(query, { variables, ...otherOptions });
-    * 
-    * function App() {
-    *   return (
-    *     <Suspense fallback={<div>Loading</div>}>
-    *       <MyQuery />
-    *     </Suspense>
-    *   );
-    * }
-    * 
-    * function MyQuery() {
-    *   const { data } = useReadQuery(queryRef);
-    * 
-    *   // do something with `data`
-    * }
-    * ```
-    */
-    <TData = unknown, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-        options?: PreloadQueryOptions<NoInfer<TVariables>>
-    ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+export interface PreloadQueryFunction extends PreloadQueryFunction.Signatures.Evaluated {
     /**
      * A function that returns a promise that resolves when the query has finished
      * loading. The promise resolves with the `QueryReference` itself.
@@ -253,6 +132,399 @@ export interface PreloadQueryFunction {
      */
     toPromise<TQueryRef extends PreloadedQueryRef<any, any, any>>(queryRef: TQueryRef): Promise<TQueryRef>;
 }
+export declare namespace PreloadQueryFunction {
+    interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
+    }
+    namespace DocumentationTypes {
+        /**
+        * @deprecated Avoid manually specifying generics on `preloadQuery`.
+        * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+        *
+        *
+        * A function that will begin loading a query when called. It's result can be
+        * read by `useReadQuery` which will suspend until the query is loaded.
+        * This is useful when you want to start loading a query as early as possible
+        * outside of a React component.
+        * 
+        * @example
+        * 
+        * ```js
+        * const preloadQuery = createQueryPreloader(client);
+        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+        * 
+        * function App() {
+        *   return (
+        *     <Suspense fallback={<div>Loading</div>}>
+        *       <MyQuery />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function MyQuery() {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   // do something with `data`
+        * }
+        * ```
+        */
+        interface PreloadQueryFunction_Deprecated extends PreloadQueryFunction {
+        }
+    }
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | PreloadQueryOptions<TVariables>> = TOptions extends any ? PreloadedQueryRef<TData, TVariables, ResultForOptions.States<TOptions, DefaultOptions>> : never;
+    namespace ResultForOptions {
+        type States<TOptions, TDefaultOptions extends DefaultOptions = DefaultOptions> = "complete" | "streaming" | (OptionWithFallback<TOptions, TDefaultOptions, "errorPolicy"> extends ("none") ? never : "empty") | (OptionWithFallback<TOptions, TDefaultOptions, "returnPartialData"> extends false ? never : "partial");
+    }
+    namespace Signatures {
+        interface Classic {
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: PreloadQueryOptions<NoInfer<TVariables>>
+            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                errorPolicy: "ignore" | "all";
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "empty">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: PreloadQueryOptions<NoInfer<TVariables>> & {
+                returnPartialData: true;
+            }): PreloadedQueryRef<TData, TVariables, "complete" | "streaming" | "partial">;
+            /**
+            * @deprecated Avoid manually specifying generics on `preloadQuery`.
+            * Instead, rely on TypeScript's type inference along with a correctly typed `TypedDocumentNode` to get accurate types for your query results.
+            * 
+            * 
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables = OperationVariables>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: PreloadQueryOptions<NoInfer<TVariables>>
+            ] : [options: PreloadQueryOptions<NoInfer<TVariables>>]): PreloadedQueryRef<TData, TVariables, "complete" | "streaming">;
+        }
+        /**
+        * A function that will begin loading a query when called. It's result can be
+        * read by `useReadQuery` which will suspend until the query is loaded.
+        * This is useful when you want to start loading a query as early as possible
+        * outside of a React component.
+        * 
+        * @example
+        * 
+        * ```js
+        * const preloadQuery = createQueryPreloader(client);
+        * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+        * 
+        * function App() {
+        *   return (
+        *     <Suspense fallback={<div>Loading</div>}>
+        *       <MyQuery />
+        *     </Suspense>
+        *   );
+        * }
+        * 
+        * function MyQuery() {
+        *   const { data } = useReadQuery(queryRef);
+        * 
+        *   // do something with `data`
+        * }
+        * ```
+        */
+        interface Modern {
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends never>(query: {} extends TVariables ? DocumentNode | TypedDocumentNode<TData, TVariables> : never): PreloadQueryFunction.ResultForOptions<TData, TVariables, Record<string, never>>;
+            /**
+            * A function that will begin loading a query when called. It's result can be
+            * read by `useReadQuery` which will suspend until the query is loaded.
+            * This is useful when you want to start loading a query as early as possible
+            * outside of a React component.
+            * 
+            * @example
+            * 
+            * ```js
+            * const preloadQuery = createQueryPreloader(client);
+            * const queryRef = preloadQuery(query, { variables, ...otherOptions });
+            * 
+            * function App() {
+            *   return (
+            *     <Suspense fallback={<div>Loading</div>}>
+            *       <MyQuery />
+            *     </Suspense>
+            *   );
+            * }
+            * 
+            * function MyQuery() {
+            *   const { data } = useReadQuery(queryRef);
+            * 
+            *   // do something with `data`
+            * }
+            * ```
+            */
+            <TData, TVariables extends OperationVariables, TOptions extends PreloadQueryOptions<NoInfer<TVariables>> & VariablesOption<TVariables & {
+                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions] : [options: TOptions]): PreloadQueryFunction.ResultForOptions<TData, TVariables, TOptions>;
+        }
+        type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+    }
+}
 /**
  * A higher order function that returns a `preloadQuery` function which
  * can be used to begin loading a query with the given `client`. This is useful

package/__cjs/version.cjs

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

package/core/ApolloClient.d.ts

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