@apollo/client 4.2.9 → 4.2.11

package/core/RefetchEventManager.js

@@ -27,7 +27,7 @@ export class RefetchEventManager {
         }
         if (this.client) {
             if (__DEV__) {
-                __DEV__ && invariant.warn(101);
+                __DEV__ && invariant.warn(102);
             }
             this.disconnect();
         }
@@ -96,13 +96,13 @@ export class RefetchEventManager {
         const [payload] = args;
         if (!this.client) {
             if (__DEV__) {
-                __DEV__ && invariant.warn(102, source);
+                __DEV__ && invariant.warn(103, source);
             }
             return;
         }
         if (!this.hasSource(source)) {
             if (__DEV__) {
-                __DEV__ && invariant.warn(103, source);
+                __DEV__ && invariant.warn(104, source);
             }
             return;
         }

package/invariantErrorCodes.js

@@ -444,98 +444,98 @@ const client = new ApolloClient({
     message: "You must provide an `updateQuery` function when using `fetchMore` with a `no-cache` fetch policy."
   },
 
-  89: {
+  90: {
     file: "@apollo/client/core/QueryManager.js",
     message: "QueryManager stopped while query was in flight"
   },
 
-  90: {
+  91: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "this.localState",
     message: "Mutation '%s' contains `@client` fields with variables provided by `@export` but local state has not been configured."
   },
 
-  91: {
+  92: {
     file: "@apollo/client/core/QueryManager.js",
     message: "Store reset while query was in flight (not completed in link chain)"
   },
 
-  94: {
+  95: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "!this.getDocumentInfo(query).hasClientExports || this.localState",
     message: "Subscription '%s' contains `@client` fields with variables provided by `@export` but local state has not been configured."
   },
 
-  95: {
+  96: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "this.localState",
     message: "%s '%s' contains `@client` fields but local state has not been configured."
   },
 
-  96: {
+  97: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "!hasIncrementalDirective",
     message: "%s '%s' contains `@client` and `@defer` directives. These cannot be used together."
   },
 
-  97: {
+  98: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "this.localState",
     message: "Query '%s' contains `@client` fields with variables provided by `@export` but local state has not been configured."
   },
 
-  99: {
+  100: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "this.localState",
     message: "Query '%s' contains `@client` fields but local state has not been configured."
   },
 
-  100: {
+  101: {
     file: "@apollo/client/core/QueryManager.js",
     condition: "didEmitValue",
     message: "The link chain completed without emitting a value. This is likely unintentional and should be updated to emit a value before completing."
   },
 
-  104: {
+  105: {
     file: "@apollo/client/cache/inmemory/entityStore.js",
     condition: "typeof dataId === \"string\"",
     message: "store.merge expects a string ID"
   },
 
-  107: {
+  108: {
     file: "@apollo/client/cache/inmemory/key-extractor.js",
     condition: "extracted !== void 0",
     message: `Missing field '%s' while extracting keyFields from %s`
   },
 
-  108: {
+  109: {
     file: "@apollo/client/cache/inmemory/policies.js",
     condition: "!old || old === which",
     message: `Cannot change root %s __typename more than once`
   },
 
-  111: {
+  112: {
     file: "@apollo/client/cache/inmemory/policies.js",
     message: "Cannot automatically merge arrays"
   },
 
-  112: {
+  113: {
     file: "@apollo/client/cache/inmemory/readFromStore.js",
     message: `No fragment named %s`
   },
 
-  113: {
+  114: {
     file: "@apollo/client/cache/inmemory/readFromStore.js",
     condition: "!isReference(value)",
     message: `Missing selection set for object of type %s returned for query field %s`
   },
 
-  114: {
+  115: {
     file: "@apollo/client/cache/inmemory/writeToStore.js",
     message: `Could not identify object %s`
   },
 
-  116: {
+  117: {
     file: "@apollo/client/cache/inmemory/writeToStore.js",
     message: `No fragment named %s`
   }
@@ -647,37 +647,56 @@ Did you mean to call refetch(variables) instead of refetch({ variables })?`
     message: "Cannot poll on 'cache-only' query '%s' and as such, polling is disabled. Please use a different fetch policy."
   },
 
-  92: {
+  89: {
+    file: "@apollo/client/core/QueryInfo.js",
+
+    message: `The network result for query %s was written to the cache, but reading it back returned a partial result.
+
+A \`read\` or \`merge\` function left missing fields after this write. Because the cache result is incomplete, Apollo Client cannot apply it to the network result. The raw network result was returned instead, and doesn't include any transformed values returned from \`read\` functions.
+
+To address this problem (which is not a bug in Apollo Client), check the \`read\` and \`merge\` functions for the fields in this query. A \`read\` or \`merge\` function that leaves missing fields leaves the cache unable to fulfill the query's data requirements.
+
+  missing fields: %o
+  network result: %o
+  cache result: %o
+
+For more information, please refer to the documentation:
+
+  * Customizing cache field behavior: https://go.apollo.dev/c/cache-field-behavior
+`
+  },
+
+  93: {
     file: "@apollo/client/core/QueryManager.js",
     message: `Unknown query named "%s" requested in refetchQueries options.include array`
   },
 
-  93: {
+  94: {
     file: "@apollo/client/core/QueryManager.js",
     message: `Unknown anonymous query requested in refetchQueries options.include array`
   },
 
-  98: {
+  99: {
     file: "@apollo/client/core/QueryManager.js",
     message: '[%s]: Fragments masked by data masking are inaccessible when using fetch policy "no-cache". Please add `@unmask` to each fragment spread to access the data.'
   },
 
-  101: {
+  102: {
     file: "@apollo/client/core/RefetchEventManager.js",
     message: "Connected an `ApolloClient` instance to a `RefetchEventManager` that was already connected to a different `ApolloClient`. The previous client has been disconnected and will no longer receive refetch events from this manager."
   },
 
-  102: {
+  103: {
     file: "@apollo/client/core/RefetchEventManager.js",
     message: "Received '%s' event but an `ApolloClient` instance is not connected to the `RefetchEventManager`. No queries will refetch. Pass the manager to the `refetchEventManager` option on the `ApolloClient` constructor."
   },
 
-  103: {
+  104: {
     file: "@apollo/client/core/RefetchEventManager.js",
     message: "Received '%s' event but no source is configured for it on the `RefetchEventManager`. No queries will refetch. Add the event to the `sources` option or call `setEventSource`."
   },
 
-  105: {
+  106: {
     file: "@apollo/client/cache/inmemory/entityStore.js",
 
     message: "cache.modify: You are trying to write a Reference that is not part of the store: %o\n" +
@@ -685,24 +704,24 @@ Did you mean to call refetch(variables) instead of refetch({ variables })?`
         "`toReference(object, true)`"
   },
 
-  106: {
+  107: {
     file: "@apollo/client/cache/inmemory/entityStore.js",
 
     message: "cache.modify: Writing an array with a mix of both References and Objects will not result in the Objects being normalized correctly.\n" +
         "Please convert the object instance %o to a Reference before writing it to the cache by calling `toReference(object, true)`."
   },
 
-  109: {
+  110: {
     file: "@apollo/client/cache/inmemory/policies.js",
     message: `Inferring subtype %s of supertype %s`
   },
 
-  110: {
+  111: {
     file: "@apollo/client/cache/inmemory/policies.js",
     message: `Undefined 'from' passed to readField with arguments %s`
   },
 
-  117: {
+  118: {
     file: "@apollo/client/cache/inmemory/writeToStore.js",
 
     message: `Cache data may be lost when replacing the %s field of a %s object.
@@ -721,7 +740,7 @@ For more information about these options, please refer to the documentation:
 `
   },
 
-  118: {
+  119: {
     file: "@apollo/client/cache/core/cache.js",
     message: "Could not identify object passed to `from` for '%s' fragment, either because the object is non-normalized or the key fields are missing. If you are masking this object, please ensure the key fields are requested by the parent object."
   }
@@ -743,7 +762,7 @@ export const devError = {
     message: "Unhandled GraphQL subscription error"
   },
 
-  115: {
+  116: {
     file: "@apollo/client/cache/inmemory/writeToStore.js",
     message: `Missing field '%s' while writing result %o`
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/client",
-  "version": "4.2.9",
+  "version": "4.2.11",
   "description": "A fully-featured caching GraphQL client.",
   "private": false,
   "keywords": [

package/react/hooks/useBackgroundQuery.d.ts

@@ -2,7 +2,7 @@ import type { ApolloClient, DefaultContext, DocumentNode, ErrorPolicy, Operation
 import type { SubscribeToMoreFunction } from "@apollo/client";
 import type { QueryRef } from "@apollo/client/react";
 import type { FetchMoreFunction, RefetchFunction } from "@apollo/client/react/internal";
-import type { DocumentationTypes as UtilityDocumentationTypes, NoInfer, OptionWithFallback, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
+import type { NoInfer, OptionWithFallback, Prettify, SignatureStyle, VariablesOption } from "@apollo/client/utilities/internal";
 import type { SkipToken } from "./constants.js";
 export declare namespace useBackgroundQuery {
     import _self = useBackgroundQuery;
@@ -114,16 +114,32 @@ export declare namespace useBackgroundQuery {
             * ```
             */
             skip?: boolean;
+            /**
+            * An object containing all of the GraphQL variables your query requires to execute.
+            * 
+            * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+            * 
+            * @docGroup 1. Operation options
+            */
+            variables?: unknown;
         }
     }
     type Options<TVariables extends OperationVariables = OperationVariables> = Base.Options & VariablesOption<TVariables>;
     namespace DocumentationTypes {
         namespace useBackgroundQuery {
-            interface Options<TVariables extends OperationVariables = OperationVariables> extends Base.Options, UtilityDocumentationTypes.VariableOptions<TVariables> {
+            interface Options<TVariables extends OperationVariables = OperationVariables> extends Base.Options {
+                /**
+                * An object containing all of the GraphQL variables your query requires to execute.
+                * 
+                * Each key in the object corresponds to a variable name, and that key's value corresponds to the variable value.
+                * 
+                * @docGroup 1. Operation options
+                */
+                variables?: TVariables;
             }
         }
     }
-    interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables> {
+    interface Result<TData = unknown, TVariables extends OperationVariables = OperationVariables, TErrorPolicy extends ErrorPolicy | undefined = undefined> {
         /**
         * A function that enables you to execute a [subscription](https://www.apollographql.com/docs/react/data/subscriptions/), usually to subscribe to specific fields that were included in the query.
         * 
@@ -155,7 +171,7 @@ export declare namespace useBackgroundQuery {
         * @remarks
         * Calling this function will cause the component to re-suspend, unless the call site is wrapped in [`startTransition`](https://react.dev/reference/react/startTransition).
         */
-        refetch: RefetchFunction<TData, TVariables>;
+        refetch: RefetchFunction<TData, TVariables, TErrorPolicy>;
     }
     namespace DocumentationTypes {
         namespace useBackgroundQuery {
@@ -166,9 +182,20 @@ export declare namespace useBackgroundQuery {
     interface DefaultOptions extends ApolloClient.DefaultOptions.WatchQuery.Calculated {
         skip: false;
     }
-    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Options<TVariables> | SkipToken> = [
+    type OptionsFor<TVariables extends OperationVariables, TOptions extends {
+        variables?: unknown;
+    }> = useBackgroundQuery.Options<NoInfer<TVariables>> & {
+        variables?: Prettify<TVariables & {
+            [K in keyof TOptions["variables"]]: K extends keyof TVariables ? TVariables[K] : never;
+        }>;
+    } & (Exclude<keyof Exclude<TOptions, SkipToken>, keyof useBackgroundQuery.Options<any>> extends infer InvalidOptionNames extends string ? [
+        InvalidOptionNames
+    ] extends [never] ? unknown : {
+        [K in InvalidOptionNames]: never;
+    } : never);
+    type ResultForOptions<TData, TVariables extends OperationVariables, TOptions extends Record<string, never> | Base.Options | SkipToken> = [
         queryRef: TOptions extends any ? TOptions extends SkipToken ? undefined : QueryRef<TData, TVariables, "complete" | "streaming" | ((OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> extends "none" ? never : "empty") | (OptionWithFallback<TOptions, DefaultOptions, "returnPartialData"> extends false ? never : "partial"))> | (OptionWithFallback<TOptions, DefaultOptions, "skip"> extends false ? never : undefined) : never,
-        result: useBackgroundQuery.Result<TData, TVariables>
+        result: useBackgroundQuery.Result<TData, TVariables, OptionWithFallback<TOptions, DefaultOptions, "errorPolicy"> & ErrorPolicy>
     ];
     namespace DocumentationTypes {
         interface useBackgroundQuery {
@@ -434,13 +461,14 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 /** @deprecated `returnPartialData` has no effect on `no-cache` queries */
                 returnPartialData: boolean;
                 fetchPolicy: "no-cache";
+                errorPolicy?: TErrorPolicy;
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -503,12 +531,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
-                errorPolicy: "ignore" | "all";
+                errorPolicy: TErrorPolicy & ("ignore" | "all");
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -571,12 +599,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
-                errorPolicy: "ignore" | "all";
+                errorPolicy: TErrorPolicy & ("ignore" | "all");
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming" | "partial" | "empty">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -639,11 +667,11 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
-                errorPolicy: "ignore" | "all";
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                errorPolicy: TErrorPolicy & ("ignore" | "all");
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming" | "empty">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -706,12 +734,13 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
                 returnPartialData: false;
+                errorPolicy?: TErrorPolicy;
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -774,12 +803,13 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
                 returnPartialData: boolean;
+                errorPolicy?: TErrorPolicy;
             }): [
                 (QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | undefined),
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -842,11 +872,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
+                errorPolicy?: TErrorPolicy;
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -909,11 +940,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
+                errorPolicy?: TErrorPolicy;
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming" | "partial">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -976,11 +1008,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 skip: boolean;
+                errorPolicy?: TErrorPolicy;
             }): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -1105,11 +1138,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: false;
+                errorPolicy?: TErrorPolicy;
             })): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -1172,11 +1206,12 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
                 returnPartialData: boolean;
+                errorPolicy?: TErrorPolicy;
             })): [
                 (QueryRef<TData, TVariables, "complete" | "streaming" | "partial"> | undefined),
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -1239,11 +1274,17 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-                options?: useBackgroundQuery.Options<NoInfer<TVariables>>
-            ] : [options: useBackgroundQuery.Options<NoInfer<TVariables>>]): [
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                    errorPolicy?: TErrorPolicy;
+                }
+            ] : [
+                options: useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                    errorPolicy?: TErrorPolicy;
+                }
+            ]): [
                 QueryRef<TData, TVariables, "complete" | "streaming">,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -1306,11 +1347,17 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
-                options?: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>
-            ] : [options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>]): [
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                    errorPolicy?: TErrorPolicy;
+                })
+            ] : [
+                options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                    errorPolicy?: TErrorPolicy;
+                })
+            ]): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
@@ -1373,9 +1420,11 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred">(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | useBackgroundQuery.Options<NoInfer<TVariables>>): [
+            <TData, TVariables extends OperationVariables, _INFERENCE_ONLY_DO_NOT_SPECIFY extends "inferred", TErrorPolicy extends ErrorPolicy | undefined = undefined>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, options: SkipToken | (useBackgroundQuery.Options<NoInfer<TVariables>> & {
+                errorPolicy?: TErrorPolicy;
+            })): [
                 QueryRef<TData, TVariables, "complete" | "streaming"> | undefined,
-                useBackgroundQuery.Result<TData, TVariables>
+                useBackgroundQuery.Result<TData, TVariables, TErrorPolicy>
             ];
             /**
             * @deprecated Avoid manually specifying generics on `useBackgroundQuery`.
@@ -2627,9 +2676,11 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, TOptions extends useBackgroundQuery.Options<NoInfer<TVariables>> & VariablesOption<TVariables & {
-                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions] : [options: TOptions]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions>;
+            <TData, TVariables extends OperationVariables, TOptions extends Base.Options>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: TOptions & useBackgroundQuery.OptionsFor<TVariables, TOptions>
+            ] : [
+                options: TOptions & useBackgroundQuery.OptionsFor<TVariables, TOptions>
+            ]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions>;
             /**
             * For a detailed explanation of useBackgroundQuery, see the [fetching with Suspense reference](https://www.apollographql.com/docs/react/data/suspense).
             * 
@@ -2753,9 +2804,11 @@ export declare namespace useBackgroundQuery {
             * @param query - A GraphQL query document parsed into an AST by `gql`.
             * @param options - An optional object containing options for the query. Instead of passing a `useBackgroundQuery.Options` object into the hook, you can also pass a [`skipToken`](#skiptoken) to prevent the `useBackgroundQuery` hook from executing the query or suspending.
             */
-            <TData, TVariables extends OperationVariables, TOptions extends useBackgroundQuery.Options<NoInfer<TVariables>> & VariablesOption<TVariables & {
-                [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
-            }>>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [options?: TOptions | SkipToken] : [options: TOptions | SkipToken]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions | SkipToken>;
+            <TData, TVariables extends OperationVariables, TOptions extends Base.Options>(query: DocumentNode | TypedDocumentNode<TData, TVariables>, ...[options]: {} extends TVariables ? [
+                options?: (TOptions & useBackgroundQuery.OptionsFor<TVariables, TOptions>) | SkipToken
+            ] : [
+                options: (TOptions & useBackgroundQuery.OptionsFor<TVariables, TOptions>) | SkipToken
+            ]): useBackgroundQuery.ResultForOptions<TData, TVariables, TOptions | SkipToken>;
         }
         type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
     }