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

package/__cjs/core/ApolloClient.d.cts

@@ -1,5 +1,6 @@
 import type { DocumentNode } from "graphql";
 import type { Observable } from "rxjs";
+import type { InternalTypes } from "@apollo/client";
 import type { ApolloCache, Cache, IgnoreModifier, Reference } from "@apollo/client/cache";
 import type { Incremental } from "@apollo/client/incremental";
 import type { ApolloLink } from "@apollo/client/link";
@@ -7,18 +8,34 @@ import type { ClientAwarenessLink } from "@apollo/client/link/client-awareness";
 import type { LocalState } from "@apollo/client/local-state";
 import type { MaybeMasked, Unmasked } from "@apollo/client/masking";
 import { DocumentTransform } from "@apollo/client/utilities";
-import type { VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
+import type { LazyType, OptionWithFallback, SignatureStyle, VariablesOption, variablesUnknownSymbol } from "@apollo/client/utilities/internal";
 import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
+import type { DeclareDefaultOptions, DefaultOptions } from "./defaultOptions.cjs";
 import type { ObservableQuery } from "./ObservableQuery.cjs";
 import type { DefaultContext, ErrorLike, InternalRefetchQueriesInclude, InternalRefetchQueriesResult, MutationQueryReducersMap, MutationUpdaterFunction, NormalizedExecutionResult, OnQueryUpdated, OperationVariables, RefetchQueriesInclude, RefetchQueriesPromiseResults, SubscriptionObservable, TypedDocumentNode } from "./types.cjs";
 import type { ErrorPolicy, FetchPolicy, MutationFetchPolicy, NextFetchPolicyContext, RefetchWritePolicy, WatchQueryFetchPolicy } from "./watchQueryOptions.cjs";
+/**
+* @knipignore
+* @internal
+* For some reason, without this export the build stop drops references to `DefaultOptions` and `DeclareDefaultOptions`, resulting in a broken build.
+* Adding this fixes that, although it's not particularly elegant.
+* 
+* @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+*/
+export interface ReferenceToAvoidDroppingImportOnBuild {
+    _1: DeclareDefaultOptions.Mutate;
+    _2: DefaultOptions;
+}
 export declare namespace ApolloClient {
-    interface DefaultOptions {
-        watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
-        query?: Partial<ApolloClient.QueryOptions<any, any>>;
-        mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
+    export type { DeclareDefaultOptions, DefaultOptions };
+    export namespace DocumentationTypes {
+        interface DefaultOptions {
+            watchQuery?: Partial<ApolloClient.WatchQueryOptions<any, any>>;
+            query?: Partial<ApolloClient.QueryOptions<any, any>>;
+            mutate?: Partial<ApolloClient.MutateOptions<any, any, any>>;
+        }
     }
-    interface Options {
+    export interface Options extends InternalTypes.DefaultOptionsParentObject {
         /**
          * An `ApolloLink` instance to serve as Apollo Client's network layer. For more information, see [Advanced HTTP networking](https://www.apollographql.com/docs/react/networking/advanced-http-networking/).
          */
@@ -47,12 +64,6 @@ export declare namespace ApolloClient {
          * @defaultValue `true`
          */
         queryDeduplication?: boolean;
-        /**
-         * Provide this object to set application-wide default values for options you can provide to the `watchQuery`, `query`, and `mutate` functions. See below for an example object.
-         *
-         * See this [example object](https://www.apollographql.com/docs/react/api/core/ApolloClient#example-defaultoptions-object).
-         */
-        defaultOptions?: ApolloClient.DefaultOptions;
         defaultContext?: Partial<DefaultContext>;
         /**
          * If `true`, Apollo Client will assume results read from the cache are never mutated by application code, which enables substantial performance optimizations.
@@ -96,7 +107,7 @@ export declare namespace ApolloClient {
          */
         experiments?: ApolloClient.Experiment[];
     }
-    interface DevtoolsOptions {
+    export interface DevtoolsOptions {
         /**
          * If `true`, the [Apollo Client Devtools](https://www.apollographql.com/docs/react/development-testing/developer-tooling/#apollo-client-devtools) browser extension can connect to this `ApolloClient` instance.
          *
@@ -110,7 +121,7 @@ export declare namespace ApolloClient {
          */
         name?: string;
     }
-    type MutateOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = {
+    export type MutateOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache> = {
         /**
         * By providing either an object or a callback function that, when invoked after
         * a mutation, allows you to return optimistic data and optionally skip updates
@@ -212,28 +223,122 @@ export declare namespace ApolloClient {
         */
         mutation: DocumentNode | TypedDocumentNode<TData, TVariables>;
     } & VariablesOption<NoInfer<TVariables>>;
-    interface MutateResult<TData = unknown> {
-        /**
-        * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
-        * is `all` or `ignore` and the server returns a GraphQL response with `errors`
-        * but not `data` or a network error is returned.
-        */
-        data: TData | undefined;
+    export namespace mutate {
+        interface DefaultOptions extends ApolloClient.DefaultOptions.Mutate.Calculated {
+        }
+        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 {
+                /**
+                * @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.
+                *
+                *
+                * 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 = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+            }
+            interface Modern {
+                /**
+                * 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, TCache extends ApolloCache, TOptions extends ApolloClient.MutateOptions<NoInfer<TData>, NoInfer<TVariables>, TCache> & VariablesOption<TVariables & {
+                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+                }>>(options: TOptions & {
+                    mutation: TypedDocumentNode<TData, TVariables>;
+                }): Promise<ApolloClient.mutate.ResultForOptions<TData, TVariables, TCache, TOptions>>;
+            }
+            type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+        }
         /**
-        * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+        * 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'`.
         * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+        * It takes options as an object with the following keys and values:
         */
-        error?: ErrorLike;
+        interface Signature extends Signatures.Evaluated {
+        }
+    }
+    export type MutateResultMap<TData = unknown> = {
+        none: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            data: TData;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: never;
+        };
+        all: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            data: TData | undefined;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: ErrorLike;
+        };
+        ignore: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            data: TData | undefined;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: never;
+        };
+        undefined: {
+            /**
+            * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
+            * is `all` or `ignore` and the server returns a GraphQL response with `errors`
+            * but not `data` or a network error is returned.
+            */
+            data: TData | undefined;
+            /**
+            * If the mutation produces one or more errors, this object contains either an array of `graphQLErrors` or a single `networkError`. Otherwise, this value is `undefined`.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            */
+            error?: ErrorLike;
+        };
+    };
+    export type MutateResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = MutateResultMap<TData>[`${TErrorPolicy}`] & {
         /**
         * Custom extensions returned from the GraphQL server
         */
         extensions?: Record<string, unknown>;
-    }
+    };
     /**
      * Query options.
      */
-    type QueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    export type QueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
         /**
         * A GraphQL query string parsed into an AST with the gql template literal.
         * 
@@ -267,83 +372,140 @@ export declare namespace ApolloClient {
         */
         fetchPolicy?: FetchPolicy;
     } & VariablesOption<NoInfer<TVariables>>;
-    type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = TErrorPolicy extends "none" ? {
-        /**
-        * An object containing the result of your GraphQL query after it completes.
-        * 
-        * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
-        * 
-        * @docGroup 1. Operation data
-        */
-        data: TData;
-        /**
-        * A single ErrorLike object describing the error that occurred during the latest
-        * query execution.
-        * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-        * 
-        * @docGroup 1. Operation data
-        */
-        error?: never;
-    } : TErrorPolicy extends "all" ? {
-        /**
-        * An object containing the result of your GraphQL query after it completes.
-        * 
-        * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
-        * 
-        * @docGroup 1. Operation data
-        */
-        data: TData | undefined;
-        /**
-        * A single ErrorLike object describing the error that occurred during the latest
-        * query execution.
-        * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-        * 
-        * @docGroup 1. Operation data
-        */
-        error?: ErrorLike;
-    } : TErrorPolicy extends "ignore" ? {
-        /**
-        * An object containing the result of your GraphQL query after it completes.
-        * 
-        * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
-        * 
-        * @docGroup 1. Operation data
-        */
-        data: TData | undefined;
-        /**
-        * A single ErrorLike object describing the error that occurred during the latest
-        * query execution.
-        * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-        * 
-        * @docGroup 1. Operation data
-        */
-        error?: never;
-    } : {
-        /**
-        * An object containing the result of your GraphQL query after it completes.
-        * 
-        * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
-        * 
-        * @docGroup 1. Operation data
-        */
-        data: TData | undefined;
+    export type QueryResultMap<TData = unknown> = {
+        none: {
+            /**
+            * An object containing the result of your GraphQL query after it completes.
+            * 
+            * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+            * 
+            * @docGroup 1. Operation data
+            */
+            data: TData;
+            /**
+            * A single ErrorLike object describing the error that occurred during the latest
+            * query execution.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            * 
+            * @docGroup 1. Operation data
+            */
+            error?: never;
+        };
+        all: {
+            /**
+            * An object containing the result of your GraphQL query after it completes.
+            * 
+            * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+            * 
+            * @docGroup 1. Operation data
+            */
+            data: TData | undefined;
+            /**
+            * A single ErrorLike object describing the error that occurred during the latest
+            * query execution.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            * 
+            * @docGroup 1. Operation data
+            */
+            error?: ErrorLike;
+        };
+        ignore: {
+            /**
+            * An object containing the result of your GraphQL query after it completes.
+            * 
+            * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+            * 
+            * @docGroup 1. Operation data
+            */
+            data: TData | undefined;
+            /**
+            * A single ErrorLike object describing the error that occurred during the latest
+            * query execution.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            * 
+            * @docGroup 1. Operation data
+            */
+            error?: never;
+        };
+        undefined: {
+            /**
+            * An object containing the result of your GraphQL query after it completes.
+            * 
+            * This value might be `undefined` if a query results in one or more errors (depending on the query's `errorPolicy`).
+            * 
+            * @docGroup 1. Operation data
+            */
+            data: TData | undefined;
+            /**
+            * A single ErrorLike object describing the error that occurred during the latest
+            * query execution.
+            * 
+            * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
+            * 
+            * @docGroup 1. Operation data
+            */
+            error?: ErrorLike;
+        };
+    };
+    export type QueryResult<TData = unknown, TErrorPolicy extends ErrorPolicy | undefined = undefined> = QueryResultMap<TData>[`${TErrorPolicy}`];
+    export namespace query {
+        interface DefaultOptions extends ApolloClient.DefaultOptions.Query.Calculated {
+        }
+        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 {
+                /**
+                * @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.
+                *
+                *
+                * 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 = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
+            }
+            interface Modern {
+                /**
+                * 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, TOptions extends ApolloClient.QueryOptions<NoInfer<TData>, NoInfer<TVariables>> & VariablesOption<TVariables & {
+                    [K in Exclude<keyof TOptions["variables"], keyof TVariables>]?: never;
+                }>>(options: TOptions & {
+                    query: TypedDocumentNode<TData, TVariables>;
+                }): Promise<ApolloClient.query.ResultForOptions<TData, TVariables, TOptions>>;
+            }
+            type Evaluated = SignatureStyle extends "classic" ? Classic : Modern;
+        }
         /**
-        * A single ErrorLike object describing the error that occurred during the latest
-        * query execution.
+        * 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.
         * 
-        * For more information, see [Handling operation errors](https://www.apollographql.com/docs/react/data/error-handling/).
-        * 
-        * @docGroup 1. Operation data
+        * @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.
         */
-        error?: ErrorLike;
-    };
+        interface Signature extends Signatures.Evaluated {
+        }
+    }
     /**
      * Options object for the `client.refetchQueries` method.
      */
-    interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
+    export interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
         /**
          * Optional function that updates cached fields to trigger refetches of queries that include those fields.
          */
@@ -377,9 +539,9 @@ export declare namespace ApolloClient {
      * immediately by examining the additional `queries` and `results` properties of
      * the `RefetchQueriesResult<TResult> object`.
      */
-    interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>>, RefetchQueriesResult.AdditionalProperties<TResult> {
+    export interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>>, RefetchQueriesResult.AdditionalProperties<TResult> {
     }
-    namespace RefetchQueriesResult {
+    export namespace RefetchQueriesResult {
         interface AdditionalProperties<TResult> {
             /**
              * An array of ObservableQuery objects corresponding 1:1 to TResult values
@@ -396,7 +558,7 @@ export declare namespace ApolloClient {
             results: InternalRefetchQueriesResult<TResult>[];
         }
     }
-    type SubscribeOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    export type SubscribeOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
         /**
         * A GraphQL document, often created with `gql` from the `graphql-tag`
         * package, that contains a single subscription inside of it.
@@ -419,7 +581,7 @@ export declare namespace ApolloClient {
         */
         extensions?: Record<string, any>;
     } & VariablesOption<NoInfer<TVariables>>;
-    interface SubscribeResult<TData = unknown> {
+    export interface SubscribeResult<TData = unknown> {
         /**
         * The data returned from your mutation. Can be `undefined` if the `errorPolicy`
         * is `all` or `ignore` and the server returns a GraphQL response with `errors`
@@ -437,9 +599,9 @@ export declare namespace ApolloClient {
         */
         extensions?: Record<string, unknown>;
     }
-    type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
-    type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
-    interface ObservableFragment<TData = unknown> extends Observable<ApolloClient.WatchFragmentResult<TData>> {
+    export type WatchFragmentOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = ApolloCache.WatchFragmentOptions<TData, TVariables>;
+    export type WatchFragmentResult<TData = unknown> = ApolloCache.WatchFragmentResult<MaybeMasked<TData>>;
+    export interface ObservableFragment<TData = unknown> extends Observable<ApolloClient.WatchFragmentResult<TData>> {
         /**
          * Return the current result for the fragment.
          */
@@ -448,7 +610,7 @@ export declare namespace ApolloClient {
     /**
      * Watched query options.
      */
-    type WatchQueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+    export type WatchQueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
         /**
         * Specifies how the query interacts with the Apollo Client cache during execution (for example, whether it checks the cache for results before sending a request to the server).
         * 
@@ -580,8 +742,8 @@ export declare namespace ApolloClient {
             optimistic?: boolean;
         }
     }
-    type ReadQueryOptions<TData, TVariables extends OperationVariables> = Base.ReadQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
-    namespace DocumentationTypes {
+    export type ReadQueryOptions<TData, TVariables extends OperationVariables> = Base.ReadQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
+    export namespace DocumentationTypes {
         interface ReadQueryOptions<TData, TVariables extends OperationVariables> extends Base.ReadQueryOptions<TData, TVariables> {
             /**
              * Any variables that the GraphQL query may depend on.
@@ -619,7 +781,7 @@ export declare namespace ApolloClient {
             optimistic?: boolean;
         }
     }
-    namespace DocumentationTypes {
+    export namespace DocumentationTypes {
         interface ReadFragmentOptions<TData, TVariables extends OperationVariables> extends Base.ReadFragmentOptions<TData, TVariables> {
             /**
              * The root id to be used. This id should take the same form as the
@@ -639,8 +801,8 @@ export declare namespace ApolloClient {
             from?: ApolloCache.FromOptionValue<TData>;
         }
     }
-    type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
-    namespace DocumentationTypes {
+    export type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    export namespace DocumentationTypes {
         interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
             /**
              * Any variables that your GraphQL fragments depend on.
@@ -684,8 +846,8 @@ export declare namespace ApolloClient {
             extensions?: Record<string, unknown>;
         }
     }
-    type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
-    namespace DocumentationTypes {
+    export type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
+    export namespace DocumentationTypes {
         interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
             /**
              * Any variables that the GraphQL query may depend on.
@@ -726,8 +888,8 @@ export declare namespace ApolloClient {
             overwrite?: boolean;
         }
     }
-    type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
-    namespace DocumentationTypes {
+    export type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    export namespace DocumentationTypes {
         interface WriteFragmentOptions<TData, TVariables extends OperationVariables> extends Base.WriteFragmentOptions<TData, TVariables> {
             /**
              * The root id to be used. This id should take the same form as the
@@ -751,10 +913,31 @@ export declare namespace ApolloClient {
             variables?: TVariables;
         }
     }
-    interface Experiment {
+    export interface Experiment {
         (this: ApolloClient, options: ApolloClient.Options): void;
         v: 1;
     }
+    export namespace DocumentationTypes {
+        /**
+         * 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.
+         */
+        function query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>>>;
+        /**
+         * 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:
+         */
+        function mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+    }
 }
 /**
  * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
@@ -856,18 +1039,6 @@ export declare class ApolloClient {
      * a description of store reactivity.
      */
     watchQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchQueryOptions<TData, TVariables>): ObservableQuery<TData, TVariables>;
-    /**
-     * 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.
-     */
-    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables> & {
-        errorPolicy: "all";
-    }): Promise<ApolloClient.QueryResult<MaybeMasked<TData>, "all">>;
     /**
     * This resolves a single query according to the options specified and
     * returns a `Promise` which is either resolved with the resulting data
@@ -877,28 +1048,16 @@ export declare class 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.
     */
-    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables> & {
-        errorPolicy: "ignore";
-    }): Promise<ApolloClient.QueryResult<MaybeMasked<TData>, "ignore">>;
+    query: ApolloClient.query.Signature;
     /**
-    * 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.
+    * 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'`.
     * 
-    * @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.
+    * It takes options as an object with the following keys and values:
     */
-    query<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.QueryOptions<TData, TVariables>): Promise<ApolloClient.QueryResult<MaybeMasked<TData>, "none">>;
-    /**
-     * 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:
-     */
-    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+    mutate: ApolloClient.mutate.Signature;
     /**
      * This subscribes to a graphql subscription according to the options specified and returns an
      * `Observable` which either emits received data or an error.