@apollo/client 3.13.9-rc.0 → 3.14.0-alpha.1

package/core/ApolloClient.d.ts

@@ -1,22 +1,21 @@
-import type { Observable } from "rxjs";
-import type { ApolloCache, DataProxy, Reference } from "@apollo/client/cache";
-import type { WatchFragmentOptions, WatchFragmentResult } from "@apollo/client/cache";
-import type { Incremental } from "@apollo/client/incremental";
-import type { ApolloLink, FetchResult, GraphQLRequest } 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 type { DocumentTransform } from "@apollo/client/utilities";
-import { getApolloClientMemoryInternals } from "@apollo/client/utilities/internal";
+import type { DocumentNode, FormattedExecutionResult } from "graphql";
+import type { GraphQLRequest } from "../link/core/index.js";
+import { ApolloLink } from "../link/core/index.js";
+import type { ApolloCache, DataProxy, Reference } from "../cache/index.js";
+import type { DocumentTransform } from "../utilities/index.js";
+import type { Observable } from "../utilities/index.js";
+import type { UriFunction } from "../link/http/index.js";
 import type { ObservableQuery } from "./ObservableQuery.js";
-import type { DefaultContext, MutateResult, OperationVariables, QueryResult, RefetchQueriesInclude, RefetchQueriesOptions, RefetchQueriesResult, SubscribeResult, SubscriptionObservable } from "./types.js";
-import type { MutationOptions, QueryOptions, SubscriptionOptions, WatchQueryOptions } from "./watchQueryOptions.js";
+import type { DefaultContext, OperationVariables, Resolvers, RefetchQueriesOptions, RefetchQueriesResult, RefetchQueriesInclude, InteropApolloQueryResult, InteropMutateResult, InteropSubscribeResult } from "./types.js";
+import type { QueryOptions, WatchQueryOptions, MutationOptions, SubscriptionOptions } from "./watchQueryOptions.js";
+import type { FragmentMatcher } from "./LocalState.js";
+import { LocalState } from "./LocalState.js";
 export interface DefaultOptions {
     watchQuery?: Partial<WatchQueryOptions<any, any>>;
     query?: Partial<QueryOptions<any, any>>;
     mutate?: Partial<MutationOptions<any, any, any>>;
 }
-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.
      *
@@ -30,19 +29,75 @@ interface DevtoolsOptions {
      */
     name?: string;
 }
-export interface ApolloClientOptions {
+export interface ApolloClientOptions<TCacheShape> {
+    /**
+     * The URI of the GraphQL endpoint that Apollo Client will communicate with.
+     *
+     * One of `uri` or `link` is **required**. If you provide both, `link` takes precedence.
+     *
+     * @deprecated `uri` will be removed in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Instantiate an instance of `HttpClient` and pass `uri` as an option.
+     *
+     * ```js
+     * import { HttpLink } from "@apollo/client";
+     *
+     * new ApolloClient({
+     *   link: new HttpLink({ uri })
+     * });
+     * ```
+     */
+    uri?: string | UriFunction;
+    /**
+     * @deprecated `credentials` will be removed in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Instantiate an instance of `HttpClient` and pass `credentials` as an option.
+     *
+     * ```js
+     * import { HttpLink } from "@apollo/client";
+     *
+     * new ApolloClient({
+     *   link: new HttpLink({ credentials })
+     * });
+     * ```
+     */
+    credentials?: string;
+    /**
+     * An object representing headers to include in every HTTP request, such as `{Authorization: 'Bearer 1234'}`
+     *
+     * This value will be ignored when using the `link` option.
+     *
+     * @deprecated `headers` will be removed in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Instantiate an instance of `HttpClient` and pass `headers` as an option.
+     *
+     * ```js
+     * import { HttpLink } from "@apollo/client";
+     *
+     * new ApolloClient({
+     *   link: new HttpLink({ headers })
+     * });
+     * ```
+     */
+    headers?: Record<string, string>;
     /**
      * You can provide 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/).
      *
      * One of `uri` or `link` is **required**. If you provide both, `link` takes precedence.
      */
-    link: ApolloLink;
+    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;
+    cache: ApolloCache<TCacheShape>;
     /**
      * The time interval (in milliseconds) before Apollo Client force-fetches queries after a server-side render.
      *
@@ -59,7 +114,18 @@ export interface ApolloClientOptions {
      * If `true`, the [Apollo Client Devtools](https://www.apollographql.com/docs/react/development-testing/developer-tooling/#apollo-client-devtools) browser extension can connect to Apollo Client.
      *
      * The default value is `false` in production and `true` in development (if there is a `window` object).
-     * @deprecated Please use the `devtools.enabled` option.
+     *
+     * @deprecated `connectToDevTools` will be removed in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Use the `devtools.enabled` option instead.
+     *
+     * ```ts
+     * new ApolloClient({
+     *   devtools: { enabled: true }
+     * });
+     * ```
      */
     connectToDevTools?: boolean;
     /**
@@ -81,15 +147,86 @@ export interface ApolloClientOptions {
      * @defaultValue `false`
      */
     assumeImmutableResults?: boolean;
-    localState?: LocalState;
     /**
-    *
-    */
-    clientAwareness?: ClientAwarenessLink.ClientAwarenessOptions;
+     * @deprecated `resolvers` has been moved in Apollo Client 4.0. This option is
+     * safe to use in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * `resolvers` will need to be passed as the `resolvers` option to an instance
+     * of `LocalState`. That `LocalState` instance should be provided as the
+     * `localState` option to the `ApolloClient` constructor.
+     */
+    resolvers?: Resolvers | Resolvers[];
+    /**
+     * @deprecated `typeDefs` will be removed in Apollo Client 4.0. It is safe to
+     * stop using this option in Apollo Client 3.x.
+     */
+    typeDefs?: string | string[] | DocumentNode | DocumentNode[];
+    /**
+     * @deprecated Custom fragment matchers will no longer be supported in Apollo
+     * Client 4.0 and has been replaced by `cache.fragmentMatches`. It is safe to
+     * continue using this in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * Leverage `possibleTypes` with `InMemoryCache` to ensure fragments match
+     * correctly. Ensure `possibleTypes` include local types if needed. This
+     * option should then be removed. If working with a 3rd party cache
+     * implementation, ensure the 3rd party cache implements the
+     * `cache.fragmentMatches` method.
+     */
+    fragmentMatcher?: FragmentMatcher;
+    /**
+     * A custom name (e.g., `iOS`) that identifies this particular client among your set of clients. Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
+     *
+     * @deprecated `name` has been moved to `clientAwareness.name` in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Use `clientAwareness.name` to set the client awareness name.
+     *
+     * ```ts
+     * new ApolloClient({ clientAwareness: { name } });
+     * ```
+     */
+    name?: string;
     /**
-    *
-    */
-    enhancedClientAwareness?: ClientAwarenessLink.EnhancedClientAwarenessOptions;
+     * A custom version that identifies the current version of this particular client (e.g., `1.2`). Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
+     *
+     * This is **not** the version of Apollo Client that you are using, but rather any version string that helps you differentiate between versions of your client.
+     *
+     * @deprecated `name` has been moved to `clientAwareness.version` in Apollo Client 4.0.
+     *
+     * **Recommended now**
+     *
+     * Use `clientAwareness.version` to set the client awareness version.
+     *
+     * ```ts
+     * new ApolloClient({ clientAwareness: { version } });
+     * ```
+     */
+    version?: string;
+    clientAwareness?: {
+        /**
+         * A custom name (e.g., `iOS`) that identifies this particular client among your set of clients. Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
+         */
+        name?: string;
+        /**
+         * A custom version that identifies the current version of this particular client (e.g., `1.2`). Apollo Server and Apollo Studio use this property as part of the [client awareness](https://www.apollographql.com/docs/apollo-server/monitoring/metrics#identifying-distinct-clients) feature.
+         *
+         * This is **not** the version of Apollo Client that you are using, but rather any version string that helps you differentiate between versions of your client.
+         */
+        version?: string;
+    };
     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.
@@ -103,42 +240,49 @@ export interface ApolloClientOptions {
      * @defaultValue false
      */
     dataMasking?: boolean;
-    /**
-     * Determines the strategy used to parse incremental chunks from `@defer`
-     * queries.
-     */
-    incrementalHandler?: Incremental.Handler<any>;
 }
+import { mergeOptions } from "../utilities/index.js";
+import { getApolloClientMemoryInternals } from "../utilities/caching/getMemoryInternals.js";
+import type { WatchFragmentOptions, WatchFragmentResult } from "../cache/core/cache.js";
+import type { MaybeMasked, Unmasked } from "../masking/index.js";
+export { mergeOptions };
 /**
  * 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 implements DataProxy {
+export declare class ApolloClient<TCacheShape = any> implements DataProxy {
     link: ApolloLink;
-    cache: ApolloCache;
-    /**
-     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`.
-     */
-    disableNetworkFetches: never;
-    set prioritizeCacheValues(value: boolean);
+    cache: ApolloCache<TCacheShape>;
     /**
-     * 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.
+     * @deprecated `disableNetworkFetches` has been renamed to `prioritizeCacheValues`
+     * in Apollo Client 4.0.
      *
-     * This can e.g. be used to prioritize the cache during the first render after SSR.
+     * **Recommended now**
+     *
+     * Access `client.prioritizeCacheValues` instead.
      */
-    get prioritizeCacheValues(): boolean;
+    disableNetworkFetches: boolean;
     version: string;
     queryDeduplication: boolean;
     defaultOptions: DefaultOptions;
+    readonly typeDefs: ApolloClientOptions<TCacheShape>["typeDefs"];
     readonly devtoolsConfig: DevtoolsOptions;
     private queryManager;
     private devToolsHookCb?;
     private resetStoreCallbacks;
     private clearStoreCallbacks;
+    localState: LocalState<TCacheShape>;
+    /**
+     * 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;
+    set prioritizeCacheValues(value: boolean);
     /**
      * Constructs an instance of `ApolloClient`.
      *
@@ -165,7 +309,7 @@ export declare class ApolloClient implements DataProxy {
      * });
      * ```
      */
-    constructor(options: ApolloClientOptions);
+    constructor(options: ApolloClientOptions<TCacheShape>);
     private connectToDevTools;
     /**
      * The `DocumentTransform` used to modify GraphQL documents before a request
@@ -173,12 +317,6 @@ export declare class ApolloClient implements DataProxy {
      * 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.
@@ -203,7 +341,7 @@ export declare class ApolloClient implements DataProxy {
      * 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: WatchQueryOptions<TVariables, TData>): ObservableQuery<TData, TVariables>;
+    watchQuery<T = any, TVariables extends OperationVariables = OperationVariables>(options: WatchQueryOptions<TVariables, T>): ObservableQuery<T, TVariables>;
     /**
      * This resolves a single query according to the options specified and
      * returns a `Promise` which is either resolved with the resulting data
@@ -213,7 +351,7 @@ export declare class ApolloClient implements DataProxy {
      * 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: QueryOptions<TVariables, TData>): Promise<QueryResult<MaybeMasked<TData>>>;
+    query<T = any, TVariables extends OperationVariables = OperationVariables>(options: QueryOptions<TVariables, T>): Promise<InteropApolloQueryResult<MaybeMasked<T>>>;
     /**
      * 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
@@ -222,12 +360,12 @@ export declare class ApolloClient implements DataProxy {
      *
      * It takes options as an object with the following keys and values:
      */
-    mutate<TData = unknown, TVariables extends OperationVariables = OperationVariables, TCache extends ApolloCache = ApolloCache>(options: MutationOptions<TData, TVariables, TCache>): Promise<MutateResult<MaybeMasked<TData>>>;
+    mutate<TData = any, TVariables extends OperationVariables = OperationVariables, TContext extends Record<string, any> = DefaultContext, TCache extends ApolloCache<any> = ApolloCache<any>>(options: MutationOptions<TData, TVariables, TContext>): Promise<InteropMutateResult<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: SubscriptionOptions<TVariables, TData>): SubscriptionObservable<SubscribeResult<MaybeMasked<TData>>>;
+    subscribe<T = any, TVariables extends OperationVariables = OperationVariables>(options: SubscriptionOptions<TVariables, T>): Observable<InteropSubscribeResult<MaybeMasked<T>>>;
     /**
      * 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
@@ -237,7 +375,7 @@ export declare class ApolloClient implements DataProxy {
      * @param optimistic - Set to `true` to allow `readQuery` to return
      * optimistic results. Is `false` by default.
      */
-    readQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, TData>, optimistic?: boolean): Unmasked<TData> | null;
+    readQuery<T = any, TVariables = OperationVariables>(options: DataProxy.Query<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
     /**
      * Watches the cache store of the fragment according to the options specified
      * and returns an `Observable`. We can subscribe to this
@@ -254,7 +392,7 @@ export declare class ApolloClient implements DataProxy {
      * the cache to identify the fragment and optionally specify whether to react
      * to optimistic updates.
      */
-    watchFragment<TData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TData, TVariables>): Observable<WatchFragmentResult<TData>>;
+    watchFragment<TFragmentData = unknown, TVariables = OperationVariables>(options: WatchFragmentOptions<TFragmentData, TVariables>): Observable<WatchFragmentResult<TFragmentData>>;
     /**
      * 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
@@ -269,13 +407,13 @@ export declare class ApolloClient implements DataProxy {
      * @param optimistic - Set to `true` to allow `readFragment` to return
      * optimistic results. Is `false` by default.
      */
-    readFragment<T = unknown, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): Unmasked<T> | null;
+    readFragment<T = any, TVariables = OperationVariables>(options: DataProxy.Fragment<TVariables, T>, optimistic?: boolean): Unmasked<T> | 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 `dataIdFromObject` then use `writeFragment`.
      */
-    writeQuery<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteQueryOptions<TData, TVariables>): Reference | undefined;
+    writeQuery<TData = any, TVariables = OperationVariables>(options: DataProxy.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
@@ -287,9 +425,9 @@ export declare class ApolloClient implements DataProxy {
      * in a document with multiple fragments then you must also specify a
      * `fragmentName`.
      */
-    writeFragment<TData = unknown, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
+    writeFragment<TData = any, TVariables = OperationVariables>(options: DataProxy.WriteFragmentOptions<TData, TVariables>): Reference | undefined;
     __actionHookForDevTools(cb: () => any): void;
-    __requestRaw(payload: GraphQLRequest): Observable<FetchResult<unknown>>;
+    __requestRaw(payload: GraphQLRequest): Observable<FormattedExecutionResult>;
     /**
      * 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
@@ -306,7 +444,7 @@ export declare class ApolloClient implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    resetStore(): Promise<QueryResult<any>[] | null>;
+    resetStore(): Promise<InteropApolloQueryResult<any>[] | null>;
     /**
      * Remove all data from the store. Unlike `resetStore`, `clearStore` will
      * not refetch any active queries.
@@ -336,7 +474,7 @@ export declare class ApolloClient implements DataProxy {
      * active queries.
      * Takes optional parameter `includeStandby` which will include queries in standby-mode when refetching.
      */
-    reFetchObservableQueries(includeStandby?: boolean): Promise<QueryResult<any>[]>;
+    reFetchObservableQueries(includeStandby?: boolean): Promise<InteropApolloQueryResult<any>[]>;
     /**
      * Refetches specified active queries. Similar to "reFetchObservableQueries()" but with a specific list of queries.
      *
@@ -348,7 +486,7 @@ export declare class ApolloClient implements DataProxy {
      * re-execute any queries then you should make sure to stop watching any
      * active queries.
      */
-    refetchQueries<TCache extends ApolloCache = ApolloCache, TResult = Promise<QueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
+    refetchQueries<TCache extends ApolloCache<any> = ApolloCache<TCacheShape>, TResult = Promise<InteropApolloQueryResult<any>>>(options: RefetchQueriesOptions<TCache, TResult>): RefetchQueriesResult<TResult>;
     /**
      * Get all currently active `ObservableQuery` objects, in a `Map` keyed by
      * query ID strings.
@@ -360,11 +498,11 @@ export declare class ApolloClient implements DataProxy {
      * 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.
      */
-    getObservableQueries(include?: RefetchQueriesInclude): Set<ObservableQuery<any>>;
+    getObservableQueries(include?: RefetchQueriesInclude): Map<string, ObservableQuery<any>>;
     /**
      * Exposes the cache's complete state, in a serializable format for later restoration.
      */
-    extract(optimistic?: boolean): unknown;
+    extract(optimistic?: boolean): TCacheShape;
     /**
      * Replaces existing state in the cache (if any) with the values expressed by
      * `serializedState`.
@@ -372,7 +510,73 @@ export declare class ApolloClient implements DataProxy {
      * Called when hydrating a cache (server side rendering, or offline storage),
      * and also (potentially) during hot reloads.
      */
-    restore(serializedState: unknown): ApolloCache;
+    restore(serializedState: TCacheShape): ApolloCache<TCacheShape>;
+    /**
+     * Add additional local resolvers.
+     *
+     * @deprecated `addResolvers` will been removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * Use `client.localState.addResolvers(resolvers)`. Alternatively, store
+     * the `LocalState` instance in a separate variable and call `addResolvers` on
+     * that.
+     */
+    addResolvers(resolvers: Resolvers | Resolvers[]): void;
+    /**
+     * Set (override existing) local resolvers.
+     *
+     * @deprecated `setResolvers` will been removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * If possible, stop using the `setResolvers` method.
+     *
+     * **When upgrading**
+     *
+     * Remove the use of `setResolvers`.
+     */
+    setResolvers(resolvers: Resolvers | Resolvers[]): void;
+    /**
+     * Get all registered local resolvers.
+     *
+     * @deprecated `getResolvers` will be removed in Apollo Client 4.0. It is
+     * safe to continue using this method in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * If possible, stop using the `getResolvers` method.
+     *
+     * **When upgrading**
+     *
+     * Remove the use of `getResolvers`.
+     */
+    getResolvers(): Resolvers;
+    /**
+     * Set a custom local state fragment matcher.
+     *
+     * @deprecated Custom fragment matchers will no longer be supported in Apollo
+     * Client 4.0 and has been replaced by `cache.fragmentMatches`. It is safe to
+     * continue using `setLocalStateFragmentMatcher` in Apollo Client 3.x.
+     *
+     * **Recommended now**
+     *
+     * No action needed
+     *
+     * **When upgrading**
+     *
+     * Leverage `possibleTypes` with `InMemoryCache` to ensure fragments match
+     * correctly. Ensure `possibleTypes` include local types if needed. If working
+     * with a 3rd party cache implementation, ensure the 3rd party cache implements
+     * the `cache.fragmentMatches` method. This function should no longer be used.
+     */
+    setLocalStateFragmentMatcher(fragmentMatcher: FragmentMatcher): void;
     /**
      * Define a new ApolloLink (or link chain) that Apollo Client will use.
      */
@@ -394,6 +598,7 @@ export declare class ApolloClient implements DataProxy {
      * ```json
      *{
      *  limits:     {
+     *    parser: 1000,
      *    canonicalStringify: 1000,
      *    print: 2000,
      *    'documentTransform.cache': 2000,
@@ -409,6 +614,7 @@ export declare class ApolloClient implements DataProxy {
      *    'inMemoryCache.executeSubSelectedArray': 5000
      *  },
      *  sizes: {
+     *    parser: 26,
      *    canonicalStringify: 4,
      *    print: 14,
      *    addTypenameDocumentTransform: [
@@ -458,5 +664,4 @@ export declare class ApolloClient implements DataProxy {
      */
     getMemoryInternals?: typeof getApolloClientMemoryInternals;
 }
-export {};
-//# sourceMappingURL=ApolloClient.d.ts.map
+//# sourceMappingURL=ApolloClient.d.ts.map