@depup/apollo__client 4.1.6-depup.0

package/__cjs/core/ApolloClient.d.cts

@@ -0,0 +1,1210 @@
+import type { DocumentNode } from "graphql";
+import type { Observable } from "rxjs";
+import type { ApolloCache, Cache, IgnoreModifier, Reference } from "@apollo/client/cache";
+import type { Incremental } from "@apollo/client/incremental";
+import type { ApolloLink } from "@apollo/client/link";
+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 { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
+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";
+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>>;
+    }
+    interface Options {
+        /**
+         * 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/).
+         */
+        link: ApolloLink;
+        /**
+         * The cache that Apollo Client should use to store query results locally. The recommended cache is `InMemoryCache`, which is provided by the `@apollo/client` package.
+         *
+         * For more information, see [Configuring the cache](https://www.apollographql.com/docs/react/caching/cache-configuration/).
+         */
+        cache: ApolloCache;
+        /**
+         * The time interval (in milliseconds) before Apollo Client force-fetches queries after a server-side render.
+         *
+         * @defaultValue `0` (no delay)
+         */
+        ssrForceFetchDelay?: number;
+        /**
+         * When using Apollo Client for [server-side rendering](https://www.apollographql.com/docs/react/performance/server-side-rendering/), set this to `true` so that the [`getDataFromTree` function](../react/ssr/#getdatafromtree) can work effectively.
+         *
+         * @defaultValue `false`
+         */
+        ssrMode?: boolean;
+        /**
+         * If `false`, Apollo Client sends every created query to the server, even if a _completely_ identical query (identical in terms of query string, variable values, and operationName) is already in flight.
+         *
+         * @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.
+         *
+         * @defaultValue `false`
+         */
+        assumeImmutableResults?: boolean;
+        localState?: LocalState;
+        /**
+        * 
+        */
+        clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
+        /**
+        * 
+        */
+        enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
+        documentTransform?: DocumentTransform;
+        /**
+         * Configuration used by the [Apollo Client Devtools extension](https://www.apollographql.com/docs/react/development-testing/developer-tooling/#apollo-client-devtools) for this client.
+         *
+         * @since 3.11.0
+         */
+        devtools?: ApolloClient.DevtoolsOptions;
+        /**
+         * Determines if data masking is enabled for the client.
+         *
+         * @defaultValue false
+         */
+        dataMasking?: boolean;
+        /**
+         * Determines the strategy used to parse incremental chunks from `@defer`
+         * queries.
+         */
+        incrementalHandler?: Incremental.Handler<any>;
+        /**
+         * @experimental
+         * Allows passing in "experiments", experimental features that might one day
+         * become part of Apollo Client's core functionality.
+         * Keep in mind that these features might change the core of Apollo Client.
+         * Do not pass in experiments that are not provided by Apollo.
+         */
+        experiments?: ApolloClient.Experiment[];
+    }
+    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.
+         *
+         * The default value is `false` in production and `true` in development if there is a `window` object.
+         */
+        enabled?: boolean;
+        /**
+         * Optional name for this `ApolloClient` instance in the devtools. This is
+         * useful when you instantiate multiple clients and want to be able to
+         * identify them by name.
+         */
+        name?: string;
+    }
+    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
+        * via the `IGNORE` sentinel object, Apollo Client caches this temporary
+        * (and potentially incorrect) response until the mutation completes, enabling
+        * more responsive UI updates.
+        * 
+        * For more information, see [Optimistic mutation results](https://www.apollographql.com/docs/react/performance/optimistic-ui/).
+        * 
+        * @docGroup 3. Caching options
+        */
+        optimisticResponse?: Unmasked<NoInfer<TData>> | ((vars: TVariables, { IGNORE }: {
+            IGNORE: IgnoreModifier;
+        }) => Unmasked<NoInfer<TData>> | IgnoreModifier);
+        /**
+        * A `MutationQueryReducersMap`, which is map from query names to
+        * mutation query reducers. Briefly, this map defines how to incorporate the
+        * results of the mutation into the results of queries that are currently
+        * being watched by your application.
+        */
+        updateQueries?: MutationQueryReducersMap<TData>;
+        /**
+        * An array (or a function that _returns_ an array) that specifies which queries you want to refetch after the mutation occurs.
+        * 
+        * Each array value can be either:
+        * 
+        * - An object containing the `query` to execute, along with any `variables`
+        * 
+        * - A string indicating the operation name of the query to refetch
+        * 
+        * @docGroup 1. Operation options
+        */
+        refetchQueries?: ((result: NormalizedExecutionResult<Unmasked<TData>>) => InternalRefetchQueriesInclude) | InternalRefetchQueriesInclude;
+        /**
+        * If `true`, makes sure all queries included in `refetchQueries` are completed before the mutation is considered complete.
+        * 
+        * The default value is `false` (queries are refetched asynchronously).
+        * 
+        * @docGroup 1. Operation options
+        */
+        awaitRefetchQueries?: boolean;
+        /**
+        * A function used to update the Apollo Client cache after the mutation completes.
+        * 
+        * For more information, see [Updating the cache after a mutation](https://www.apollographql.com/docs/react/data/mutations#updating-the-cache-after-a-mutation).
+        * 
+        * @docGroup 3. Caching options
+        */
+        update?: MutationUpdaterFunction<TData, TVariables, TCache>;
+        /**
+        * Optional callback for intercepting queries whose cache data has been updated by the mutation, as well as any queries specified in the `refetchQueries: [...]` list passed to `client.mutate`.
+        * 
+        * Returning a `Promise` from `onQueryUpdated` will cause the final mutation `Promise` to await the returned `Promise`. Returning `false` causes the query to be ignored.
+        * 
+        * @docGroup 1. Operation options
+        */
+        onQueryUpdated?: OnQueryUpdated<any>;
+        /**
+        * Specifies how the mutation handles a response that returns both GraphQL errors and partial results.
+        * 
+        * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+        * 
+        * The default value is `none`, meaning that the mutation result includes error details but _not_ partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup 2. Networking options
+        */
+        context?: DefaultContext;
+        /**
+        * Provide `no-cache` if the mutation's result should _not_ be written to the Apollo Client cache.
+        * 
+        * The default value is `network-only` (which means the result _is_ written to the cache).
+        * 
+        * Unlike queries, mutations _do not_ support [fetch policies](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy) besides `network-only` and `no-cache`.
+        * 
+        * @docGroup 3. Caching options
+        */
+        fetchPolicy?: MutationFetchPolicy;
+        /**
+        * To avoid retaining sensitive information from mutation root field
+        * arguments, Apollo Client v3.4+ automatically clears any `ROOT_MUTATION`
+        * fields from the cache after each mutation finishes. If you need this
+        * information to remain in the cache, you can prevent the removal by passing
+        * `keepRootFields: true` to the mutation. `ROOT_MUTATION` result data are
+        * also passed to the mutation `update` function, so we recommend obtaining
+        * the results that way, rather than using this option, if possible.
+        */
+        keepRootFields?: boolean;
+        /**
+        * A GraphQL document, often created with `gql` from the `graphql-tag`
+        * package, that contains a single mutation inside of it.
+        * 
+        * @docGroup 1. Operation options
+        */
+        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;
+        /**
+        * 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;
+        /**
+        * Custom extensions returned from the GraphQL server
+        */
+        extensions?: Record<string, unknown>;
+    }
+    /**
+     * Query options.
+     */
+    type QueryOptions<TData = unknown, TVariables extends OperationVariables = OperationVariables> = {
+        /**
+        * A GraphQL query string parsed into an AST with the gql template literal.
+        * 
+        * @docGroup 1. Operation options
+        */
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+        * Specifies how the query handles a response that returns both GraphQL errors and partial results.
+        * 
+        * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+        * 
+        * The default value is `none`, meaning that the query result includes error details but not partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup 2. Networking options
+        */
+        context?: DefaultContext;
+        /**
+        * 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).
+        * 
+        * For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
+        * 
+        * The default value is `cache-first`.
+        * 
+        * @docGroup 3. Caching options
+        */
+        fetchPolicy?: FetchPolicy;
+    } & VariablesOption<NoInfer<TVariables>>;
+    interface QueryResult<TData = unknown> {
+        /**
+        * 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;
+    }
+    /**
+     * Options object for the `client.refetchQueries` method.
+     */
+    interface RefetchQueriesOptions<TCache extends ApolloCache, TResult> {
+        /**
+         * Optional function that updates cached fields to trigger refetches of queries that include those fields.
+         */
+        updateCache?: (cache: TCache) => void;
+        /**
+         * Optional array specifying queries to refetch. Each element can be either a query's string name or a `DocumentNode` object.
+         *
+         * Pass `"active"` as a shorthand to refetch all active queries, or `"all"` to refetch all active and inactive queries.
+         *
+         * Analogous to the [`options.refetchQueries`](https://www.apollographql.com/docs/react/data/mutations/#options) array for mutations.
+         */
+        include?: RefetchQueriesInclude;
+        /**
+         * If `true`, the `options.updateCache` function is executed on a temporary optimistic layer of `InMemoryCache`, so its modifications can be discarded from the cache after observing which fields it invalidated.
+         *
+         * Defaults to `false`, meaning `options.updateCache` updates the cache in a lasting way.
+         */
+        optimistic?: boolean;
+        /**
+         * Optional callback function that's called once for each `ObservableQuery` that's either affected by `options.updateCache` or listed in `options.include` (or both).
+         *
+         * If `onQueryUpdated` is not provided, the default implementation returns the result of calling `observableQuery.refetch()`. When `onQueryUpdated` is provided, it can dynamically decide whether (and how) each query should be refetched.
+         *
+         * Returning `false` from `onQueryUpdated` prevents the associated query from being refetched.
+         */
+        onQueryUpdated?: OnQueryUpdated<TResult> | null;
+    }
+    /**
+     * The result of client.refetchQueries is thenable/awaitable, if you just want
+     * an array of fully resolved results, but you can also access the raw results
+     * immediately by examining the additional `queries` and `results` properties of
+     * the `RefetchQueriesResult<TResult> object`.
+     */
+    interface RefetchQueriesResult<TResult> extends Promise<RefetchQueriesPromiseResults<TResult>>, RefetchQueriesResult.AdditionalProperties<TResult> {
+    }
+    namespace RefetchQueriesResult {
+        interface AdditionalProperties<TResult> {
+            /**
+             * An array of ObservableQuery objects corresponding 1:1 to TResult values
+             * in the results arrays (both the `result` property and the resolved value).
+             */
+            queries: ObservableQuery<any>[];
+            /**
+             * An array of results that were either returned by `onQueryUpdated`, or provided by default in the absence of `onQueryUpdated`, including pending promises.
+             *
+             * If `onQueryUpdated` returns `false` for a given query, no result is provided for that query.
+             *
+             * If `onQueryUpdated` returns `true`, the resulting `Promise<ApolloQueryResult<any>>` is included in the `results` array instead of `true`.
+             */
+            results: InternalRefetchQueriesResult<TResult>[];
+        }
+    }
+    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.
+        */
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+        * How you want your component to interact with the Apollo cache. For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
+        */
+        fetchPolicy?: FetchPolicy;
+        /**
+        * Specifies the `ErrorPolicy` to be used for this operation
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * Shared context between your component and your network interface (Apollo Link).
+        */
+        context?: DefaultContext;
+        /**
+        * Shared context between your component and your network interface (Apollo Link).
+        */
+        extensions?: Record<string, any>;
+    } & VariablesOption<NoInfer<TVariables>>;
+    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`
+        * 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;
+        /**
+        * Custom extensions returned from the GraphQL server
+        */
+        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>> {
+        /**
+         * Return the current result for the fragment.
+         */
+        getCurrentResult: () => ApolloClient.WatchFragmentResult<TData>;
+    }
+    /**
+     * Watched query options.
+     */
+    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).
+        * 
+        * For details, see [Setting a fetch policy](https://www.apollographql.com/docs/react/data/queries/#setting-a-fetch-policy).
+        * 
+        * The default value is `cache-first`.
+        * 
+        * @docGroup 3. Caching options
+        */
+        fetchPolicy?: WatchQueryFetchPolicy;
+        /**
+        * Specifies the `FetchPolicy` to be used after this query has completed.
+        * 
+        * @docGroup 3. Caching options
+        */
+        nextFetchPolicy?: WatchQueryFetchPolicy | ((this: WatchQueryOptions<TData, TVariables>, currentFetchPolicy: WatchQueryFetchPolicy, context: NextFetchPolicyContext<TData, TVariables>) => WatchQueryFetchPolicy);
+        /**
+        * Defaults to the initial value of options.fetchPolicy, but can be explicitly
+        * configured to specify the WatchQueryFetchPolicy to revert back to whenever
+        * variables change (unless nextFetchPolicy intervenes).
+        * 
+        * @docGroup 3. Caching options
+        */
+        initialFetchPolicy?: WatchQueryFetchPolicy;
+        /**
+        * Specifies whether a `NetworkStatus.refetch` operation should merge
+        * incoming field data with existing data, or overwrite the existing data.
+        * Overwriting is probably preferable, but merging is currently the default
+        * behavior, for backwards compatibility with Apollo Client 3.x.
+        * 
+        * @docGroup 3. Caching options
+        */
+        refetchWritePolicy?: RefetchWritePolicy;
+        /**
+        * Specifies how the query handles a response that returns both GraphQL errors and partial results.
+        * 
+        * For details, see [GraphQL error policies](https://www.apollographql.com/docs/react/data/error-handling/#graphql-error-policies).
+        * 
+        * The default value is `none`, meaning that the query result includes error details but not partial results.
+        * 
+        * @docGroup 1. Operation options
+        */
+        errorPolicy?: ErrorPolicy;
+        /**
+        * If you're using [Apollo Link](https://www.apollographql.com/docs/react/api/link/introduction/), this object is the initial value of the `context` object that's passed along your link chain.
+        * 
+        * @docGroup 2. Networking options
+        */
+        context?: DefaultContext;
+        /**
+        * Specifies the interval (in milliseconds) at which the query polls for updated results.
+        * 
+        * The default value is `0` (no polling).
+        * 
+        * @docGroup 2. Networking options
+        */
+        pollInterval?: number;
+        /**
+        * If `true`, the in-progress query's associated component re-renders whenever the network status changes or a network error occurs.
+        * 
+        * The default value is `true`.
+        * 
+        * @docGroup 2. Networking options
+        */
+        notifyOnNetworkStatusChange?: boolean;
+        /**
+        * If `true`, the query can return partial results from the cache if the cache doesn't contain results for all queried fields.
+        * 
+        * The default value is `false`.
+        * 
+        * @docGroup 3. Caching options
+        */
+        returnPartialData?: boolean;
+        /**
+        * A callback function that's called whenever a refetch attempt occurs
+        * while polling. If the function returns `true`, the refetch is
+        * skipped and not reattempted until the next poll interval.
+        * 
+        * @docGroup 2. Networking options
+        */
+        skipPollAttempt?: () => boolean;
+        /**
+        * A GraphQL query string parsed into an AST with the gql template literal.
+        * 
+        * @docGroup 1. Operation options
+        */
+        query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+        /**
+        * @internal This API is meant for framework integrations only.
+        * Do not use for everyday use.
+        *
+        * Indicates that the variables are unknown at the time of query creation.
+        * This option can only be set when `fetchPolicy` is `'standby'`.
+        * Setting this to `true` will prevent `client.refetchQueries` from refetching
+        * this query before it has left the `'standby'` state, either by setting a
+        * `fetchPolicy`, or by calling `observableQuery.refetch()` explicitly.
+        *
+        * Changing this option after the query has been created will have no effect.
+        * 
+        * @deprecated This is an internal API and should not be used directly. This can be removed or changed at any time.
+        */
+        [variablesUnknownSymbol]?: boolean;
+    } & VariablesOption<NoInfer<TVariables>>;
+    namespace Base {
+        interface ReadQueryOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * The GraphQL query shape to be used constructed using the `gql` template
+             * string tag. The query will be used to determine the
+             * shape of the data to be read.
+             */
+            query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+            /**
+             * The root id to be used. Defaults to "ROOT_QUERY", which is the ID of the
+             * root query object. This property makes `readQuery` capable of reading data
+             * from any object in the cache.
+             */
+            id?: string;
+            /**
+             * Whether to return incomplete data rather than null.
+             * @defaultValue false
+             */
+            returnPartialData?: boolean;
+            /**
+             * Whether to read from optimistic or non-optimistic cache data.
+             * This option should be preferred over the `optimistic` parameter of the
+             * `readQuery` method.
+             * @defaultValue false
+             */
+            optimistic?: boolean;
+        }
+    }
+    type ReadQueryOptions<TData, TVariables extends OperationVariables> = Base.ReadQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
+    namespace DocumentationTypes {
+        interface ReadQueryOptions<TData, TVariables extends OperationVariables> extends Base.ReadQueryOptions<TData, TVariables> {
+            /**
+             * Any variables that the GraphQL query may depend on.
+             */
+            variables?: TVariables;
+        }
+    }
+    namespace Base {
+        interface ReadFragmentOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * A GraphQL document created using the `gql` template string tag
+             * with one or more fragments which will be used to determine
+             * the shape of data to read. If you provide more than one fragment in this
+             * document then you must also specify `fragmentName` to specify which
+             * fragment is the root fragment.
+             */
+            fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+            /**
+             * The name of the fragment in your GraphQL document to be used. If you do
+             * not provide a `fragmentName` and there is only one fragment in your
+             * `fragment` document then that fragment will be used.
+             */
+            fragmentName?: string;
+            /**
+             * Whether to return incomplete data rather than null.
+             * @defaultValue false
+             */
+            returnPartialData?: boolean;
+            /**
+             * Whether to read from optimistic or non-optimistic cache data.
+             * This option should be preferred over the `optimistic` parameter of the
+             * `readFragment` method.
+             * @defaultValue false
+             */
+            optimistic?: boolean;
+        }
+    }
+    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
+             * value returned by the `cache.identify` function. If a value with your
+             * id does not exist in the store, `null` will be returned.
+             */
+            id?: string;
+            /**
+             * An object containing a `__typename` and primary key fields
+             * (such as `id`) identifying the entity object from which the fragment will
+             * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
+             * (uncommon).
+             *
+             * @remarks
+             * `from` is given precedence over `id` when both are provided.
+             */
+            from?: ApolloCache.FromOptionValue<TData>;
+        }
+    }
+    type ReadFragmentOptions<TData, TVariables extends OperationVariables> = Base.ReadFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    namespace DocumentationTypes {
+        interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
+            /**
+             * Any variables that your GraphQL fragments depend on.
+             */
+            variables?: TVariables;
+        }
+    }
+    namespace Base {
+        interface WriteQueryOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * The GraphQL query shape to be used constructed using the `gql` template
+             * string tag. The query will be used to determine the
+             * shape of the data to be read.
+             */
+            query: DocumentNode | TypedDocumentNode<TData, TVariables>;
+            /**
+             * The root id to be used. Defaults to "ROOT_QUERY", which is the ID of the
+             * root query object. This property makes writeQuery capable of writing data
+             * to any object in the cache.
+             */
+            id?: string;
+            /**
+             * The data to write to the store.
+             */
+            data: Unmasked<TData>;
+            /**
+             * Whether to notify query watchers.
+             * @defaultValue true
+             */
+            broadcast?: boolean;
+            /**
+             * When true, ignore existing field data rather than merging it with
+             * incoming data.
+             * @defaultValue false
+             */
+            overwrite?: boolean;
+            /**
+             * GraphQL extensions for the write operation. Any provided `extensions`
+             * are available in `merge` functions.
+             */
+            extensions?: Record<string, unknown>;
+        }
+    }
+    type WriteQueryOptions<TData, TVariables extends OperationVariables> = Base.WriteQueryOptions<TData, TVariables> & VariablesOption<TVariables>;
+    namespace DocumentationTypes {
+        interface WriteQueryOptions<TData, TVariables extends OperationVariables> extends Base.WriteQueryOptions<TData, TVariables> {
+            /**
+             * Any variables that the GraphQL query may depend on.
+             */
+            variables?: TVariables;
+        }
+    }
+    namespace Base {
+        interface WriteFragmentOptions<TData, TVariables extends OperationVariables> {
+            /**
+             * A GraphQL document created using the `gql` template string tag from
+             * `graphql-tag` with one or more fragments which will be used to determine
+             * the shape of data to read. If you provide more than one fragment in this
+             * document then you must also specify `fragmentName` to specify which
+             * fragment is the root fragment.
+             */
+            fragment: DocumentNode | TypedDocumentNode<TData, TVariables>;
+            /**
+             * The name of the fragment in your GraphQL document to be used. If you do
+             * not provide a `fragmentName` and there is only one fragment in your
+             * `fragment` document then that fragment will be used.
+             */
+            fragmentName?: string;
+            /**
+             * The data to write to the store.
+             */
+            data: Unmasked<TData>;
+            /**
+             * Whether to notify query watchers.
+             * @defaultValue true
+             */
+            broadcast?: boolean;
+            /**
+             * When true, ignore existing field data rather than merging it with
+             * incoming data.
+             * @defaultValue false
+             */
+            overwrite?: boolean;
+        }
+    }
+    type WriteFragmentOptions<TData, TVariables extends OperationVariables> = Base.WriteFragmentOptions<TData, TVariables> & VariablesOption<TVariables> & Cache.CacheIdentifierOption<TData>;
+    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
+             * value returned by the `cache.identify` function. If a value with your
+             * id does not exist in the store, `null` will be returned.
+             */
+            id?: string;
+            /**
+             * An object containing a `__typename` and primary key fields
+             * (such as `id`) identifying the entity object from which the fragment will
+             * be retrieved, or a `{ __ref: "..." }` reference, or a `string` ID
+             * (uncommon).
+             *
+             * @remarks
+             * `from` is given precedence over `id` when both are provided.
+             */
+            from?: ApolloCache.FromOptionValue<TData>;
+            /**
+             * Any variables that your GraphQL fragments depend on.
+             */
+            variables?: TVariables;
+        }
+    }
+    interface Experiment {
+        (this: ApolloClient, options: ApolloClient.Options): void;
+        v: 1;
+    }
+}
+/**
+ * This is the primary Apollo Client class. It is used to send GraphQL documents (i.e. queries
+ * and mutations) to a GraphQL spec-compliant server over an `ApolloLink` instance,
+ * receive results from the server and cache the results in a store. It also delivers updates
+ * to GraphQL queries through `Observable` instances.
+ */
+export declare class ApolloClient {
+    link: ApolloLink;
+    cache: ApolloCache;
+    /**
+     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`.
+     */
+    disableNetworkFetches: never;
+    set prioritizeCacheValues(value: boolean);
+    /**
+     * Whether to prioritize cache values over network results when `query` or `watchQuery` is called.
+     * This will essentially turn a `"network-only"` or `"cache-and-network"` fetchPolicy into a `"cache-first"` fetchPolicy,
+     * but without influencing the `fetchPolicy` of the created `ObservableQuery` long-term.
+     *
+     * This can e.g. be used to prioritize the cache during the first render after SSR.
+     */
+    get prioritizeCacheValues(): boolean;
+    version: string;
+    queryDeduplication: boolean;
+    defaultOptions: ApolloClient.DefaultOptions;
+    readonly devtoolsConfig: ApolloClient.DevtoolsOptions;
+    private queryManager;
+    private devToolsHookCb?;
+    private resetStoreCallbacks;
+    private clearStoreCallbacks;
+    /**
+     * Constructs an instance of `ApolloClient`.
+     *
+     * @example
+     *
+     * ```js
+     * import { ApolloClient, InMemoryCache, HttpLink } from "@apollo/client";
+     *
+     * const cache = new InMemoryCache();
+     * const link = new HttpLink({ uri: "http://localhost:4000/" });
+     *
+     * const client = new ApolloClient({
+     *   // Provide required constructor fields
+     *   cache: cache,
+     *   link: link,
+     *
+     *   // Provide some optional constructor fields
+     *   clientAwareness: {
+     *     name: "react-web-client",
+     *     version: "1.3",
+     *   },
+     *   queryDeduplication: false,
+     * });
+     * ```
+     */
+    constructor(options: ApolloClient.Options);
+    private connectToDevTools;
+    /**
+     * The `DocumentTransform` used to modify GraphQL documents before a request
+     * is made. If a custom `DocumentTransform` is not provided, this will be the
+     * default document transform.
+     */
+    get documentTransform(): DocumentTransform;
+    /**
+     * The configured `LocalState` instance used to enable the use of `@client`
+     * fields.
+     */
+    get localState(): LocalState | undefined;
+    set localState(localState: LocalState);
+    /**
+     * Call this method to terminate any active client processes, making it safe
+     * to dispose of this `ApolloClient` instance.
+     *
+     * This method performs aggressive cleanup to prevent memory leaks:
+     *
+     * - Unsubscribes all active `ObservableQuery` instances by emitting a `completed` event
+     * - Rejects all currently running queries with "QueryManager stopped while query was in flight"
+     * - Removes all queryRefs from the suspense cache
+     */
+    stop(): void;
+    /**
+     * This watches the cache store of the query according to the options specified and
+     * returns an `ObservableQuery`. We can subscribe to this `ObservableQuery` and
+     * receive updated results through an observer when the cache store changes.
+     *
+     * Note that this method is not an implementation of GraphQL subscriptions. Rather,
+     * it uses Apollo's store in order to reactively deliver updates to your query results.
+     *
+     * For example, suppose you call watchQuery on a GraphQL query that fetches a person's
+     * first and last name and this person has a particular object identifier, provided by
+     * `cache.identify`. Later, a different query fetches that same person's
+     * first and last name and the first name has now changed. Then, any observers associated
+     * with the results of the first query will be updated with a new result object.
+     *
+     * Note that if the cache does not change, the subscriber will _not_ be notified.
+     *
+     * See [here](https://medium.com/apollo-stack/the-concepts-of-graphql-bc68bd819be3#.3mb0cbcmc) for
+     * 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>): 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:
+     */
+    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: ApolloClient.MutateOptions<TData, TVariables, TCache>): Promise<ApolloClient.MutateResult<MaybeMasked<TData>>>;
+    /**
+     * This subscribes to a graphql subscription according to the options specified and returns an
+     * `Observable` which either emits received data or an error.
+     */
+    subscribe<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.SubscribeOptions<TData, TVariables>): SubscriptionObservable<ApolloClient.SubscribeResult<MaybeMasked<TData>>>;
+    /**
+     * Tries to read some data from the store in the shape of the provided
+     * GraphQL query without making a network request. This method will start at
+     * the root query. To start at a specific id returned by `cache.identify`
+     * use `readFragment`.
+     *
+     * @param optimistic - Set to `true` to allow `readQuery` to return
+     * optimistic results. Is `false` by default.
+     */
+    readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>): Unmasked<TData> | null;
+    /**
+    * Tries to read some data from the store in the shape of the provided
+    * GraphQL query without making a network request. This method will start at
+    * the root query. To start at a specific id returned by `cache.identify`
+    * use `readFragment`.
+    * 
+    * @param optimistic - Set to `true` to allow `readQuery` to return
+    * optimistic results. Is `false` by default.
+    *      
+    *
+    * @deprecated Pass the `optimistic` argument as part of the first argument
+    * instead of passing it as a separate option.
+    */
+    readQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadQueryOptions<TData, TVariables>, 
+    /**
+     * @deprecated Pass the `optimistic` argument as part of the first argument
+     * instead of passing it as a separate option.
+     */
+    optimistic: boolean): Unmasked<TData> | null;
+    /**
+     * Watches the cache store of the fragment according to the options specified
+     * and returns an `Observable`. We can subscribe to this
+     * `Observable` and receive updated results through an
+     * observer when the cache store changes.
+     *
+     * You must pass in a GraphQL document with a single fragment or a document
+     * with multiple fragments that represent what you are reading. If you pass
+     * in a document with multiple fragments then you must also specify a
+     * `fragmentName`.
+     *
+     * @since 3.10.0
+     * @param options - An object of type `WatchFragmentOptions` that allows
+     * the cache to identify the fragment and optionally specify whether to react
+     * to optimistic updates.
+     */
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<ApolloCache.FromOptionValue<TData>>;
+    }): ApolloClient.ObservableFragment<Array<TData>>;
+    /**
+    * Watches the cache store of the fragment according to the options specified
+    * and returns an `Observable`. We can subscribe to this
+    * `Observable` and receive updated results through an
+    * observer when the cache store changes.
+    * 
+    * You must pass in a GraphQL document with a single fragment or a document
+    * with multiple fragments that represent what you are reading. If you pass
+    * in a document with multiple fragments then you must also specify a
+    * `fragmentName`.
+    * 
+    * @since 3.10.0
+    * @param options - An object of type `WatchFragmentOptions` that allows
+    * the cache to identify the fragment and optionally specify whether to react
+    * to optimistic updates.
+    */
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<null>;
+    }): ApolloClient.ObservableFragment<Array<null>>;
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: Array<ApolloCache.FromOptionValue<TData> | null>;
+    }): ApolloClient.ObservableFragment<Array<TData | null>>;
+    /**
+    * Watches the cache store of the fragment according to the options specified
+    * and returns an `Observable`. We can subscribe to this
+    * `Observable` and receive updated results through an
+    * observer when the cache store changes.
+    * 
+    * You must pass in a GraphQL document with a single fragment or a document
+    * with multiple fragments that represent what you are reading. If you pass
+    * in a document with multiple fragments then you must also specify a
+    * `fragmentName`.
+    * 
+    * @since 3.10.0
+    * @param options - An object of type `WatchFragmentOptions` that allows
+    * the cache to identify the fragment and optionally specify whether to react
+    * to optimistic updates.
+    */
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: null;
+    }): ApolloClient.ObservableFragment<null>;
+    /**
+    * Watches the cache store of the fragment according to the options specified
+    * and returns an `Observable`. We can subscribe to this
+    * `Observable` and receive updated results through an
+    * observer when the cache store changes.
+    * 
+    * You must pass in a GraphQL document with a single fragment or a document
+    * with multiple fragments that represent what you are reading. If you pass
+    * in a document with multiple fragments then you must also specify a
+    * `fragmentName`.
+    * 
+    * @since 3.10.0
+    * @param options - An object of type `WatchFragmentOptions` that allows
+    * the cache to identify the fragment and optionally specify whether to react
+    * to optimistic updates.
+    */
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables> & {
+        from: ApolloCache.FromOptionValue<TData>;
+    }): ApolloClient.ObservableFragment<TData>;
+    /**
+    * Watches the cache store of the fragment according to the options specified
+    * and returns an `Observable`. We can subscribe to this
+    * `Observable` and receive updated results through an
+    * observer when the cache store changes.
+    * 
+    * You must pass in a GraphQL document with a single fragment or a document
+    * with multiple fragments that represent what you are reading. If you pass
+    * in a document with multiple fragments then you must also specify a
+    * `fragmentName`.
+    * 
+    * @since 3.10.0
+    * @param options - An object of type `WatchFragmentOptions` that allows
+    * the cache to identify the fragment and optionally specify whether to react
+    * to optimistic updates.
+    */
+    watchFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WatchFragmentOptions<TData, TVariables>): ApolloClient.ObservableFragment<TData | null>;
+    /**
+     * Tries to read some data from the store in the shape of the provided
+     * GraphQL fragment without making a network request. This method will read a
+     * GraphQL fragment from any arbitrary id that is currently cached, unlike
+     * `readQuery` which will only read from the root query.
+     *
+     * You must pass in a GraphQL document with a single fragment or a document
+     * with multiple fragments that represent what you are reading. If you pass
+     * in a document with multiple fragments then you must also specify a
+     * `fragmentName`.
+     *
+     * @param optimistic - Set to `true` to allow `readFragment` to return
+     * optimistic results. Is `false` by default.
+     */
+    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>): Unmasked<TData> | null;
+    /**
+    * Tries to read some data from the store in the shape of the provided
+    * GraphQL fragment without making a network request. This method will read a
+    * GraphQL fragment from any arbitrary id that is currently cached, unlike
+    * `readQuery` which will only read from the root query.
+    * 
+    * You must pass in a GraphQL document with a single fragment or a document
+    * with multiple fragments that represent what you are reading. If you pass
+    * in a document with multiple fragments then you must also specify a
+    * `fragmentName`.
+    * 
+    * @param optimistic - Set to `true` to allow `readFragment` to return
+    * optimistic results. Is `false` by default.
+    *      
+    *
+    * @deprecated Pass the `optimistic` argument as part of the first argument
+    * instead of passing it as a separate option.
+    */
+    readFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.ReadFragmentOptions<TData, TVariables>, optimistic: boolean): Unmasked<TData> | null;
+    /**
+     * Writes some data in the shape of the provided GraphQL query directly to
+     * the store. This method will start at the root query. To start at a
+     * specific id returned by `cache.identify` then use `writeFragment`.
+     */
+    writeQuery<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    /**
+     * Writes some data in the shape of the provided GraphQL fragment directly to
+     * the store. This method will write to a GraphQL fragment from any arbitrary
+     * id that is currently cached, unlike `writeQuery` which will only write
+     * from the root query.
+     *
+     * You must pass in a GraphQL document with a single fragment or a document
+     * with multiple fragments that represent what you are writing. If you pass
+     * in a document with multiple fragments then you must also specify a
+     * `fragmentName`.
+     */
+    writeFragment<TData = unknown, TVariables extends OperationVariables = OperationVariables>(options: ApolloClient.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    __actionHookForDevTools(cb: () => any): void;
+    __requestRaw(request: ApolloLink.Request): Observable<ApolloLink.Result<unknown>>;
+    /**
+     * Resets your entire store by clearing out your cache and then re-executing
+     * all of your active queries. This makes it so that you may guarantee that
+     * there is no data left in your store from a time before you called this
+     * method.
+     *
+     * `resetStore()` is useful when your user just logged out. You’ve removed the
+     * user session, and you now want to make sure that any references to data you
+     * might have fetched while the user session was active is gone.
+     *
+     * It is important to remember that `resetStore()` _will_ refetch any active
+     * queries. This means that any components that might be mounted will execute
+     * their queries again using your network interface. If you do not want to
+     * re-execute any queries then you should make sure to stop watching any
+     * active queries.
+     */
+    resetStore(): Promise<ApolloClient.QueryResult<any>[] | null>;
+    /**
+     * Remove all data from the store. Unlike `resetStore`, `clearStore` will
+     * not refetch any active queries.
+     */
+    clearStore(): Promise<any[]>;
+    /**
+     * Allows callbacks to be registered that are executed when the store is
+     * reset. `onResetStore` returns an unsubscribe function that can be used
+     * to remove registered callbacks.
+     */
+    onResetStore(cb: () => Promise<any>): () => void;
+    /**
+     * Allows callbacks to be registered that are executed when the store is
+     * cleared. `onClearStore` returns an unsubscribe function that can be used
+     * to remove registered callbacks.
+     */
+    onClearStore(cb: () => Promise<any>): () => void;
+    /**
+     * Refetches all of your active queries.
+     *
+     * `reFetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
+     *
+     * It is important to remember that `reFetchObservableQueries()` _will_ refetch any active
+     * queries. This means that any components that might be mounted will execute
+     * their queries again using your network interface. If you do not want to
+     * re-execute any queries then you should make sure to stop watching any
+     * active queries.
+     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
+     *
+     * Note: `cache-only` queries are not refetched by this function.
+     *
+     * @deprecated Please use `refetchObservableQueries` instead.
+     */
+    reFetchObservableQueries: (includeStandby?: boolean) => Promise<ApolloClient.QueryResult<any>[]>;
+    /**
+     * Refetches all of your active queries.
+     *
+     * `refetchObservableQueries()` is useful if you want to bring the client back to proper state in case of a network outage
+     *
+     * It is important to remember that `refetchObservableQueries()` _will_ refetch any active
+     * queries. This means that any components that might be mounted will execute
+     * their queries again using your network interface. If you do not want to
+     * re-execute any queries then you should make sure to stop watching any
+     * active queries.
+     * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
+     *
+     * Note: `cache-only` queries are not refetched by this function.
+     */
+    refetchObservableQueries(includeStandby?: boolean): Promise<ApolloClient.QueryResult<any>[]>;
+    /**
+     * Refetches specified active queries. Similar to "refetchObservableQueries()" but with a specific list of queries.
+     *
+     * `refetchQueries()` is useful for use cases to imperatively refresh a selection of queries.
+     *
+     * It is important to remember that `refetchQueries()` _will_ refetch specified active
+     * queries. This means that any components that might be mounted will execute
+     * their queries again using your network interface. If you do not want to
+     * re-execute any queries then you should make sure to stop watching any
+     * active queries.
+     */
+    refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<ApolloClient.QueryResult<any>>>(options: ApolloClient.RefetchQueriesOptions<TCache, TResult>): ApolloClient.RefetchQueriesResult<TResult>;
+    /**
+     * Get all currently active `ObservableQuery` objects, in a `Set`.
+     *
+     * An "active" query is one that has observers and a `fetchPolicy` other than
+     * "standby" or "cache-only".
+     *
+     * You can include all `ObservableQuery` objects (including the inactive ones)
+     * by passing "all" instead of "active", or you can include just a subset of
+     * active queries by passing an array of query names or DocumentNode objects.
+     *
+     * Note: This method only returns queries that have active subscribers. Queries
+     * without subscribers are not tracked by the client.
+     */
+    getObservableQueries(include?: RefetchQueriesInclude): Set<ObservableQuery<any>>;
+    /**
+     * Exposes the cache's complete state, in a serializable format for later restoration.
+     *
+     * @remarks
+     *
+     * This can be useful for debugging in order to inspect the full state of the
+     * cache.
+     *
+     * @param optimistic - Determines whether the result contains data from the
+     * optimistic layer
+     */
+    extract(optimistic?: boolean): unknown;
+    /**
+     * Replaces existing state in the cache (if any) with the values expressed by
+     * `serializedState`.
+     *
+     * Called when hydrating a cache (server side rendering, or offline storage),
+     * and also (potentially) during hot reloads.
+     */
+    restore(serializedState: unknown): ApolloCache;
+    /**
+     * Define a new ApolloLink (or link chain) that Apollo Client will use.
+     */
+    setLink(newLink: ApolloLink): void;
+    get defaultContext(): Partial<DefaultContext>;
+    private maskedFragmentTransform;
+    private transform;
+    /**
+     * @experimental
+     * This is not a stable API - it is used in development builds to expose
+     * information to the DevTools.
+     * Use at your own risk!
+     * For more details, see [Memory Management](https://www.apollographql.com/docs/react/caching/memory-management/#measuring-cache-usage)
+     *
+     * @example
+     *
+     * ```ts
+     * console.log(client.getMemoryInternals());
+     * ```
+     *
+     * Logs output in the following JSON format:
+     * @example
+     *
+     * ```json
+     * {
+     *   "limits": {
+     *     "canonicalStringify": 1000,
+     *     "print": 2000,
+     *     "documentTransform.cache": 2000,
+     *     "queryManager.getDocumentInfo": 2000,
+     *     "PersistedQueryLink.persistedQueryHashes": 2000,
+     *     "fragmentRegistry.transform": 2000,
+     *     "fragmentRegistry.lookup": 1000,
+     *     "fragmentRegistry.findFragmentSpreads": 4000,
+     *     "cache.fragmentQueryDocuments": 1000,
+     *     "removeTypenameFromVariables.getVariableDefinitions": 2000,
+     *     "inMemoryCache.maybeBroadcastWatch": 5000,
+     *     "inMemoryCache.executeSelectionSet": 10000,
+     *     "inMemoryCache.executeSubSelectedArray": 5000
+     *   },
+     *   "sizes": {
+     *     "canonicalStringify": 4,
+     *     "print": 14,
+     *     "addTypenameDocumentTransform": [
+     *       {
+     *         "cache": 14
+     *       }
+     *     ],
+     *     "queryManager": {
+     *       "getDocumentInfo": 14,
+     *       "documentTransforms": [
+     *         {
+     *           "cache": 14
+     *         },
+     *         {
+     *           "cache": 14
+     *         }
+     *       ]
+     *     },
+     *     "fragmentRegistry": {
+     *       "findFragmentSpreads": 34,
+     *       "lookup": 20,
+     *       "transform": 14
+     *     },
+     *     "cache": {
+     *       "fragmentQueryDocuments": 22
+     *     },
+     *     "inMemoryCache": {
+     *       "executeSelectionSet": 4345,
+     *       "executeSubSelectedArray": 1206,
+     *       "maybeBroadcastWatch": 32
+     *     },
+     *     "links": [
+     *       {
+     *         "PersistedQueryLink": {
+     *           "persistedQueryHashes": 14
+     *         }
+     *       },
+     *       {
+     *         "removeTypenameFromVariables": {
+     *           "getVariableDefinitions": 14
+     *         }
+     *       }
+     *     ]
+     *   }
+     * }
+     * ```
+     */
+    getMemoryInternals?: typeof getApolloClientMemoryInternals;
+}
+//# sourceMappingURL=ApolloClient.d.cts.map